Merge pull request #363 from inthepoche/dev1.3.0

poche 1.3.0

64 files changed, 35990 insertions, 0 deletions

diff --git a/inc/3rdparty/libraries/Zend/Cache.php b/inc/3rdparty/libraries/Zend/Cache.php
new file mode 100644
index 00000000..d28cb559
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache.php
@@ -0,0 +1,250 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Cache.php 24656 2012-02-26 06:02:53Z adamlundrigan $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+abstract class Zend_Cache
+{
+
+    /**
+     * Standard frontends
+     *
+     * @var array
+     */
+    public static $standardFrontends = array('Core', 'Output', 'Class', 'File', 'Function', 'Page');
+
+    /**
+     * Standard backends
+     *
+     * @var array
+     */
+    public static $standardBackends = array('File', 'Sqlite', 'Memcached', 'Libmemcached', 'Apc', 'ZendPlatform',
+                                            'Xcache', 'TwoLevels', 'WinCache', 'ZendServer_Disk', 'ZendServer_ShMem');
+
+    /**
+     * Standard backends which implement the ExtendedInterface
+     *
+     * @var array
+     */
+    public static $standardExtendedBackends = array('File', 'Apc', 'TwoLevels', 'Memcached', 'Libmemcached', 'Sqlite', 'WinCache');
+
+    /**
+     * Only for backward compatibility (may be removed in next major release)
+     *
+     * @var array
+     * @deprecated
+     */
+    public static $availableFrontends = array('Core', 'Output', 'Class', 'File', 'Function', 'Page');
+
+    /**
+     * Only for backward compatibility (may be removed in next major release)
+     *
+     * @var array
+     * @deprecated
+     */
+    public static $availableBackends = array('File', 'Sqlite', 'Memcached', 'Libmemcached', 'Apc', 'ZendPlatform', 'Xcache', 'WinCache', 'TwoLevels');
+
+    /**
+     * Consts for clean() method
+     */
+    const CLEANING_MODE_ALL              = 'all';
+    const CLEANING_MODE_OLD              = 'old';
+    const CLEANING_MODE_MATCHING_TAG     = 'matchingTag';
+    const CLEANING_MODE_NOT_MATCHING_TAG = 'notMatchingTag';
+    const CLEANING_MODE_MATCHING_ANY_TAG = 'matchingAnyTag';
+
+    /**
+     * Factory
+     *
+     * @param mixed  $frontend        frontend name (string) or Zend_Cache_Frontend_ object
+     * @param mixed  $backend         backend name (string) or Zend_Cache_Backend_ object
+     * @param array  $frontendOptions associative array of options for the corresponding frontend constructor
+     * @param array  $backendOptions  associative array of options for the corresponding backend constructor
+     * @param boolean $customFrontendNaming if true, the frontend argument is used as a complete class name ; if false, the frontend argument is used as the end of "Zend_Cache_Frontend_[...]" class name
+     * @param boolean $customBackendNaming if true, the backend argument is used as a complete class name ; if false, the backend argument is used as the end of "Zend_Cache_Backend_[...]" class name
+     * @param boolean $autoload if true, there will no require_once for backend and frontend (useful only for custom backends/frontends)
+     * @throws Zend_Cache_Exception
+     * @return Zend_Cache_Core|Zend_Cache_Frontend
+     */
+    public static function factory($frontend, $backend, $frontendOptions = array(), $backendOptions = array(), $customFrontendNaming = false, $customBackendNaming = false, $autoload = false)
+    {
+        if (is_string($backend)) {
+            $backendObject = self::_makeBackend($backend, $backendOptions, $customBackendNaming, $autoload);
+        } else {
+            if ((is_object($backend)) && (in_array('Zend_Cache_Backend_Interface', class_implements($backend)))) {
+                $backendObject = $backend;
+            } else {
+                self::throwException('backend must be a backend name (string) or an object which implements Zend_Cache_Backend_Interface');
+            }
+        }
+        if (is_string($frontend)) {
+            $frontendObject = self::_makeFrontend($frontend, $frontendOptions, $customFrontendNaming, $autoload);
+        } else {
+            if (is_object($frontend)) {
+                $frontendObject = $frontend;
+            } else {
+                self::throwException('frontend must be a frontend name (string) or an object');
+            }
+        }
+        $frontendObject->setBackend($backendObject);
+        return $frontendObject;
+    }
+
+    /**
+     * Backend Constructor
+     *
+     * @param string  $backend
+     * @param array   $backendOptions
+     * @param boolean $customBackendNaming
+     * @param boolean $autoload
+     * @return Zend_Cache_Backend
+     */
+    public static function _makeBackend($backend, $backendOptions, $customBackendNaming = false, $autoload = false)
+    {
+        if (!$customBackendNaming) {
+            $backend  = self::_normalizeName($backend);
+        }
+        if (in_array($backend, Zend_Cache::$standardBackends)) {
+            // we use a standard backend
+            $backendClass = 'Zend_Cache_Backend_' . $backend;
+            // security controls are explicit
+            require_once realpath(dirname(__FILE__).'/..').DIRECTORY_SEPARATOR.str_replace('_', DIRECTORY_SEPARATOR, $backendClass) . '.php';
+        } else {
+            // we use a custom backend
+            if (!preg_match('~^[\w\\\\]+$~D', $backend)) {
+                Zend_Cache::throwException("Invalid backend name [$backend]");
+            }
+            if (!$customBackendNaming) {
+                // we use this boolean to avoid an API break
+                $backendClass = 'Zend_Cache_Backend_' . $backend;
+            } else {
+                $backendClass = $backend;
+            }
+            if (!$autoload) {
+                $file = str_replace('_', DIRECTORY_SEPARATOR, $backendClass) . '.php';
+                if (!(self::_isReadable($file))) {
+                    self::throwException("file $file not found in include_path");
+                }
+                require_once $file;
+            }
+        }
+        return new $backendClass($backendOptions);
+    }
+
+    /**
+     * Frontend Constructor
+     *
+     * @param string  $frontend
+     * @param array   $frontendOptions
+     * @param boolean $customFrontendNaming
+     * @param boolean $autoload
+     * @return Zend_Cache_Core|Zend_Cache_Frontend
+     */
+    public static function _makeFrontend($frontend, $frontendOptions = array(), $customFrontendNaming = false, $autoload = false)
+    {
+        if (!$customFrontendNaming) {
+            $frontend = self::_normalizeName($frontend);
+        }
+        if (in_array($frontend, self::$standardFrontends)) {
+            // we use a standard frontend
+            // For perfs reasons, with frontend == 'Core', we can interact with the Core itself
+            $frontendClass = 'Zend_Cache_' . ($frontend != 'Core' ? 'Frontend_' : '') . $frontend;
+            // security controls are explicit
+            require_once realpath(dirname(__FILE__).'/..').DIRECTORY_SEPARATOR.str_replace('_', DIRECTORY_SEPARATOR, $frontendClass) . '.php';
+        } else {
+            // we use a custom frontend
+            if (!preg_match('~^[\w\\\\]+$~D', $frontend)) {
+                Zend_Cache::throwException("Invalid frontend name [$frontend]");
+            }
+            if (!$customFrontendNaming) {
+                // we use this boolean to avoid an API break
+                $frontendClass = 'Zend_Cache_Frontend_' . $frontend;
+            } else {
+                $frontendClass = $frontend;
+            }
+            if (!$autoload) {
+                $file = str_replace('_', DIRECTORY_SEPARATOR, $frontendClass) . '.php';
+                if (!(self::_isReadable($file))) {
+                    self::throwException("file $file not found in include_path");
+                }
+                require_once $file;
+            }
+        }
+        return new $frontendClass($frontendOptions);
+    }
+
+    /**
+     * Throw an exception
+     *
+     * Note : for perf reasons, the "load" of Zend/Cache/Exception is dynamic
+     * @param  string $msg  Message for the exception
+     * @throws Zend_Cache_Exception
+     */
+    public static function throwException($msg, Exception $e = null)
+    {
+        // For perfs reasons, we use this dynamic inclusion
+        require_once 'Zend/Cache/Exception.php';
+        throw new Zend_Cache_Exception($msg, 0, $e);
+    }
+
+    /**
+     * Normalize frontend and backend names to allow multiple words TitleCased
+     *
+     * @param  string $name  Name to normalize
+     * @return string
+     */
+    protected static function _normalizeName($name)
+    {
+        $name = ucfirst(strtolower($name));
+        $name = str_replace(array('-', '_', '.'), ' ', $name);
+        $name = ucwords($name);
+        $name = str_replace(' ', '', $name);
+        if (stripos($name, 'ZendServer') === 0) {
+            $name = 'ZendServer_' . substr($name, strlen('ZendServer'));
+        }
+
+        return $name;
+    }
+
+    /**
+     * Returns TRUE if the $filename is readable, or FALSE otherwise.
+     * This function uses the PHP include_path, where PHP's is_readable()
+     * does not.
+     *
+     * Note : this method comes from Zend_Loader (see #ZF-2891 for details)
+     *
+     * @param string   $filename
+     * @return boolean
+     */
+    private static function _isReadable($filename)
+    {
+        if (!$fh = @fopen($filename, 'r', true)) {
+            return false;
+        }
+        @fclose($fh);
+        return true;
+    }
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend.php b/inc/3rdparty/libraries/Zend/Cache/Backend.php
new file mode 100644
index 00000000..803fd446
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend.php
@@ -0,0 +1,290 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Backend.php 24989 2012-06-21 07:24:13Z mabe $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Backend
+{
+    /**
+     * Frontend or Core directives
+     *
+     * =====> (int) lifetime :
+     * - Cache lifetime (in seconds)
+     * - If null, the cache is valid forever
+     *
+     * =====> (int) logging :
+     * - if set to true, a logging is activated throw Zend_Log
+     *
+     * @var array directives
+     */
+    protected $_directives = array(
+        'lifetime' => 3600,
+        'logging'  => false,
+        'logger'   => null
+    );
+
+    /**
+     * Available options
+     *
+     * @var array available options
+     */
+    protected $_options = array();
+
+    /**
+     * Constructor
+     *
+     * @param  array $options Associative array of options
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct(array $options = array())
+    {
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+    }
+
+    /**
+     * Set the frontend directives
+     *
+     * @param  array $directives Assoc of directives
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setDirectives($directives)
+    {
+        if (!is_array($directives)) Zend_Cache::throwException('Directives parameter must be an array');
+        while (list($name, $value) = each($directives)) {
+            if (!is_string($name)) {
+                Zend_Cache::throwException("Incorrect option name : $name");
+            }
+            $name = strtolower($name);
+            if (array_key_exists($name, $this->_directives)) {
+                $this->_directives[$name] = $value;
+            }
+
+        }
+
+        $this->_loggerSanity();
+    }
+
+    /**
+     * Set an option
+     *
+     * @param  string $name
+     * @param  mixed  $value
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setOption($name, $value)
+    {
+        if (!is_string($name)) {
+            Zend_Cache::throwException("Incorrect option name : $name");
+        }
+        $name = strtolower($name);
+        if (array_key_exists($name, $this->_options)) {
+            $this->_options[$name] = $value;
+        }
+    }
+
+    /**
+     * Returns an option
+     *
+     * @param string $name Optional, the options name to return
+     * @throws Zend_Cache_Exceptions
+     * @return mixed
+     */
+    public function getOption($name)
+    {
+        $name = strtolower($name);
+
+        if (array_key_exists($name, $this->_options)) {
+            return $this->_options[$name];
+        }
+
+        if (array_key_exists($name, $this->_directives)) {
+            return $this->_directives[$name];
+        }
+
+        Zend_Cache::throwException("Incorrect option name : {$name}");
+    }
+
+    /**
+     * Get the life time
+     *
+     * if $specificLifetime is not false, the given specific life time is used
+     * else, the global lifetime is used
+     *
+     * @param  int $specificLifetime
+     * @return int Cache life time
+     */
+    public function getLifetime($specificLifetime)
+    {
+        if ($specificLifetime === false) {
+            return $this->_directives['lifetime'];
+        }
+        return $specificLifetime;
+    }
+
+    /**
+     * Return true if the automatic cleaning is available for the backend
+     *
+     * DEPRECATED : use getCapabilities() instead
+     *
+     * @deprecated
+     * @return boolean
+     */
+    public function isAutomaticCleaningAvailable()
+    {
+        return true;
+    }
+
+    /**
+     * Determine system TMP directory and detect if we have read access
+     *
+     * inspired from Zend_File_Transfer_Adapter_Abstract
+     *
+     * @return string
+     * @throws Zend_Cache_Exception if unable to determine directory
+     */
+    public function getTmpDir()
+    {
+        $tmpdir = array();
+        foreach (array($_ENV, $_SERVER) as $tab) {
+            foreach (array('TMPDIR', 'TEMP', 'TMP', 'windir', 'SystemRoot') as $key) {
+                if (isset($tab[$key]) && is_string($tab[$key])) {
+                    if (($key == 'windir') or ($key == 'SystemRoot')) {
+                        $dir = realpath($tab[$key] . '\\temp');
+                    } else {
+                        $dir = realpath($tab[$key]);
+                    }
+                    if ($this->_isGoodTmpDir($dir)) {
+                        return $dir;
+                    }
+                }
+            }
+        }
+        $upload = ini_get('upload_tmp_dir');
+        if ($upload) {
+            $dir = realpath($upload);
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        if (function_exists('sys_get_temp_dir')) {
+            $dir = sys_get_temp_dir();
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        // Attemp to detect by creating a temporary file
+        $tempFile = tempnam(md5(uniqid(rand(), TRUE)), '');
+        if ($tempFile) {
+            $dir = realpath(dirname($tempFile));
+            unlink($tempFile);
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        if ($this->_isGoodTmpDir('/tmp')) {
+            return '/tmp';
+        }
+        if ($this->_isGoodTmpDir('\\temp')) {
+            return '\\temp';
+        }
+        Zend_Cache::throwException('Could not determine temp directory, please specify a cache_dir manually');
+    }
+
+    /**
+     * Verify if the given temporary directory is readable and writable
+     *
+     * @param string $dir temporary directory
+     * @return boolean true if the directory is ok
+     */
+    protected function _isGoodTmpDir($dir)
+    {
+        if (is_readable($dir)) {
+            if (is_writable($dir)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Make sure if we enable logging that the Zend_Log class
+     * is available.
+     * Create a default log object if none is set.
+     *
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _loggerSanity()
+    {
+        if (!isset($this->_directives['logging']) || !$this->_directives['logging']) {
+            return;
+        }
+
+        if (isset($this->_directives['logger'])) {
+            if ($this->_directives['logger'] instanceof Zend_Log) {
+                return;
+            }
+            Zend_Cache::throwException('Logger object is not an instance of Zend_Log class.');
+        }
+
+        // Create a default logger to the standard output stream
+        require_once 'Zend/Log.php';
+        require_once 'Zend/Log/Writer/Stream.php';
+        require_once 'Zend/Log/Filter/Priority.php';
+        $logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
+        $logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
+        $this->_directives['logger'] = $logger;
+    }
+
+    /**
+     * Log a message at the WARN (4) priority.
+     *
+     * @param  string $message
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _log($message, $priority = 4)
+    {
+        if (!$this->_directives['logging']) {
+            return;
+        }
+
+        if (!isset($this->_directives['logger'])) {
+            Zend_Cache::throwException('Logging is enabled but logger is not set.');
+        }
+        $logger = $this->_directives['logger'];
+        if (!$logger instanceof Zend_Log) {
+            Zend_Cache::throwException('Logger object is not an instance of Zend_Log class.');
+        }
+        $logger->log($message, $priority);
+    }
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php b/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php
new file mode 100644
index 00000000..c192baaf
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php
@@ -0,0 +1,127 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: ExtendedInterface.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+/**
+ * @see Zend_Cache_Backend_Interface
+ */
+//require_once 'Zend/Cache/Backend/Interface.php';
+require_once dirname(__FILE__).'/Interface.php';
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+interface Zend_Cache_Backend_ExtendedInterface extends Zend_Cache_Backend_Interface
+{
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds();
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags();
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array());
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array());
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of any matching cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array());
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage();
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array must include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id);
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime);
+
+    /**
+     * Return an associative array of capabilities (booleans) of the backend
+     *
+     * The array must include these keys :
+     * - automatic_cleaning (is automating cleaning necessary)
+     * - tags (are tags supported)
+     * - expired_read (is it possible to read expired cache records
+     *                 (for doNotTestCacheValidity option for example))
+     * - priority does the backend deal with priority when saving
+     * - infinite_lifetime (is infinite lifetime can work with this backend)
+     * - get_list (is it possible to get the list of cache ids and the complete list of tags)
+     *
+     * @return array associative of with capabilities
+     */
+    public function getCapabilities();
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/File.php b/inc/3rdparty/libraries/Zend/Cache/Backend/File.php
new file mode 100644
index 00000000..5affbcb3
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/File.php
@@ -0,0 +1,1034 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: File.php 24844 2012-05-31 19:01:36Z rob $
+ */
+
+/**
+ * @see Zend_Cache_Backend_Interface
+ */
+//require_once 'Zend/Cache/Backend/ExtendedInterface.php';
+require_once dirname(__FILE__).'/ExtendedInterface.php';
+
+/**
+ * @see Zend_Cache_Backend
+ */
+//require_once 'Zend/Cache/Backend.php';
+require_once realpath(dirname(__FILE__).'/..').DIRECTORY_SEPARATOR.'Backend.php';
+
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Backend_File extends Zend_Cache_Backend implements Zend_Cache_Backend_ExtendedInterface
+{
+    /**
+     * Available options
+     *
+     * =====> (string) cache_dir :
+     * - Directory where to put the cache files
+     *
+     * =====> (boolean) file_locking :
+     * - Enable / disable file_locking
+     * - Can avoid cache corruption under bad circumstances but it doesn't work on multithread
+     * webservers and on NFS filesystems for example
+     *
+     * =====> (boolean) read_control :
+     * - Enable / disable read control
+     * - If enabled, a control key is embeded in cache file and this key is compared with the one
+     * calculated after the reading.
+     *
+     * =====> (string) read_control_type :
+     * - Type of read control (only if read control is enabled). Available values are :
+     *   'md5' for a md5 hash control (best but slowest)
+     *   'crc32' for a crc32 hash control (lightly less safe but faster, better choice)
+     *   'adler32' for an adler32 hash control (excellent choice too, faster than crc32)
+     *   'strlen' for a length only test (fastest)
+     *
+     * =====> (int) hashed_directory_level :
+     * - Hashed directory level
+     * - Set the hashed directory structure level. 0 means "no hashed directory
+     * structure", 1 means "one level of directory", 2 means "two levels"...
+     * This option can speed up the cache only when you have many thousands of
+     * cache file. Only specific benchs can help you to choose the perfect value
+     * for you. Maybe, 1 or 2 is a good start.
+     *
+     * =====> (int) hashed_directory_umask :
+     * - deprecated
+     * - Permissions for hashed directory structure
+     *
+     * =====> (int) hashed_directory_perm :
+     * - Permissions for hashed directory structure
+     *
+     * =====> (string) file_name_prefix :
+     * - prefix for cache files
+     * - be really carefull with this option because a too generic value in a system cache dir
+     *   (like /tmp) can cause disasters when cleaning the cache
+     *
+     * =====> (int) cache_file_umask :
+     * - deprecated
+     * - Permissions for cache files
+     *
+     * =====> (int) cache_file_perm :
+     * - Permissions for cache files
+     *
+     * =====> (int) metatadatas_array_max_size :
+     * - max size for the metadatas array (don't change this value unless you
+     *   know what you are doing)
+     *
+     * @var array available options
+     */
+    protected $_options = array(
+        'cache_dir' => null,
+        'file_locking' => true,
+        'read_control' => true,
+        'read_control_type' => 'crc32',
+        'hashed_directory_level' => 0,
+        'hashed_directory_perm' => 0700,
+        'file_name_prefix' => 'zend_cache',
+        'cache_file_perm' => 0600,
+        'metadatas_array_max_size' => 100
+    );
+
+    /**
+     * Array of metadatas (each item is an associative array)
+     *
+     * @var array
+     */
+    protected $_metadatasArray = array();
+
+
+    /**
+     * Constructor
+     *
+     * @param  array $options associative array of options
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct(array $options = array())
+    {
+        parent::__construct($options);
+        if ($this->_options['cache_dir'] !== null) { // particular case for this option
+            $this->setCacheDir($this->_options['cache_dir']);
+        } else {
+            $this->setCacheDir(self::getTmpDir() . DIRECTORY_SEPARATOR, false);
+        }
+        if (isset($this->_options['file_name_prefix'])) { // particular case for this option
+            if (!preg_match('~^[a-zA-Z0-9_]+$~D', $this->_options['file_name_prefix'])) {
+                Zend_Cache::throwException('Invalid file_name_prefix : must use only [a-zA-Z0-9_]');
+            }
+        }
+        if ($this->_options['metadatas_array_max_size'] < 10) {
+            Zend_Cache::throwException('Invalid metadatas_array_max_size, must be > 10');
+        }
+
+        if (isset($options['hashed_directory_umask'])) {
+            // See #ZF-12047
+            trigger_error("'hashed_directory_umask' is deprecated -> please use 'hashed_directory_perm' instead", E_USER_NOTICE);
+            if (!isset($options['hashed_directory_perm'])) {
+                $options['hashed_directory_perm'] = $options['hashed_directory_umask'];
+            }
+        }
+        if (isset($options['hashed_directory_perm']) && is_string($options['hashed_directory_perm'])) {
+            // See #ZF-4422
+            $this->_options['hashed_directory_perm'] = octdec($this->_options['hashed_directory_perm']);
+        }
+
+        if (isset($options['cache_file_umask'])) {
+            // See #ZF-12047
+            trigger_error("'cache_file_umask' is deprecated -> please use 'cache_file_perm' instead", E_USER_NOTICE);
+            if (!isset($options['cache_file_perm'])) {
+                $options['cache_file_perm'] = $options['cache_file_umask'];
+            }
+        }
+        if (isset($options['cache_file_perm']) && is_string($options['cache_file_perm'])) {
+            // See #ZF-4422
+            $this->_options['cache_file_perm'] = octdec($this->_options['cache_file_perm']);
+        }
+    }
+
+    /**
+     * Set the cache_dir (particular case of setOption() method)
+     *
+     * @param  string  $value
+     * @param  boolean $trailingSeparator If true, add a trailing separator is necessary
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setCacheDir($value, $trailingSeparator = true)
+    {
+        if (!is_dir($value)) {
+            Zend_Cache::throwException(sprintf('cache_dir "%s" must be a directory', $value));
+        }
+        if (!is_writable($value)) {
+            Zend_Cache::throwException(sprintf('cache_dir "%s" is not writable', $value));
+        }
+        if ($trailingSeparator) {
+            // add a trailing DIRECTORY_SEPARATOR if necessary
+            $value = rtrim(realpath($value), '\\/') . DIRECTORY_SEPARATOR;
+        }
+        $this->_options['cache_dir'] = $value;
+    }
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * @param string $id cache id
+     * @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
+     * @return string|false cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false)
+    {
+        if (!($this->_test($id, $doNotTestCacheValidity))) {
+            // The cache is not hit !
+            return false;
+        }
+        $metadatas = $this->_getMetadatas($id);
+        $file = $this->_file($id);
+        $data = $this->_fileGetContents($file);
+        if ($this->_options['read_control']) {
+            $hashData = $this->_hash($data, $this->_options['read_control_type']);
+            $hashControl = $metadatas['hash'];
+            if ($hashData != $hashControl) {
+                // Problem detected by the read control !
+                $this->_log('Zend_Cache_Backend_File::load() / read_control : stored hash and computed hash do not match');
+                $this->remove($id);
+                return false;
+            }
+        }
+        return $data;
+    }
+
+    /**
+     * Test if a cache is available or not (for the given id)
+     *
+     * @param string $id cache id
+     * @return mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    public function test($id)
+    {
+        clearstatcache();
+        return $this->_test($id, false);
+    }
+
+    /**
+     * Save some string datas into a cache record
+     *
+     * Note : $data is always "string" (serialization is done by the
+     * core not by the backend)
+     *
+     * @param  string $data             Datas to cache
+     * @param  string $id               Cache id
+     * @param  array  $tags             Array of strings, the cache record will be tagged by each string entry
+     * @param  int    $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @return boolean true if no problem
+     */
+    public function save($data, $id, $tags = array(), $specificLifetime = false)
+    {
+        clearstatcache();
+        $file = $this->_file($id);
+        $path = $this->_path($id);
+        if ($this->_options['hashed_directory_level'] > 0) {
+            if (!is_writable($path)) {
+                // maybe, we just have to build the directory structure
+                $this->_recursiveMkdirAndChmod($id);
+            }
+            if (!is_writable($path)) {
+                return false;
+            }
+        }
+        if ($this->_options['read_control']) {
+            $hash = $this->_hash($data, $this->_options['read_control_type']);
+        } else {
+            $hash = '';
+        }
+        $metadatas = array(
+            'hash' => $hash,
+            'mtime' => time(),
+            'expire' => $this->_expireTime($this->getLifetime($specificLifetime)),
+            'tags' => $tags
+        );
+        $res = $this->_setMetadatas($id, $metadatas);
+        if (!$res) {
+            $this->_log('Zend_Cache_Backend_File::save() / error on saving metadata');
+            return false;
+        }
+        $res = $this->_filePutContents($file, $data);
+        return $res;
+    }
+
+    /**
+     * Remove a cache record
+     *
+     * @param  string $id cache id
+     * @return boolean true if no problem
+     */
+    public function remove($id)
+    {
+        $file = $this->_file($id);
+        $boolRemove   = $this->_remove($file);
+        $boolMetadata = $this->_delMetadatas($id);
+        return $boolMetadata && $boolRemove;
+    }
+
+    /**
+     * Clean some cache records
+     *
+     * Available modes are :
+     *
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param string $mode clean mode
+     * @param tags array $tags array of tags
+     * @return boolean true if no problem
+     */
+    public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
+    {
+        // We use this protected method to hide the recursive stuff
+        clearstatcache();
+        return $this->_clean($this->_options['cache_dir'], $mode, $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds()
+    {
+        return $this->_get($this->_options['cache_dir'], 'ids', array());
+    }
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags()
+    {
+        return $this->_get($this->_options['cache_dir'], 'tags', array());
+    }
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'matching', $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'notMatching', $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of any matching cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'matchingAny', $tags);
+    }
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @throws Zend_Cache_Exception
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage()
+    {
+        $free = disk_free_space($this->_options['cache_dir']);
+        $total = disk_total_space($this->_options['cache_dir']);
+        if ($total == 0) {
+            Zend_Cache::throwException('can\'t get disk_total_space');
+        } else {
+            if ($free >= $total) {
+                return 100;
+            }
+            return ((int) (100. * ($total - $free) / $total));
+        }
+    }
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array must include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if (time() > $metadatas['expire']) {
+            return false;
+        }
+        return array(
+            'expire' => $metadatas['expire'],
+            'tags' => $metadatas['tags'],
+            'mtime' => $metadatas['mtime']
+        );
+    }
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if (time() > $metadatas['expire']) {
+            return false;
+        }
+        $newMetadatas = array(
+            'hash' => $metadatas['hash'],
+            'mtime' => time(),
+            'expire' => $metadatas['expire'] + $extraLifetime,
+            'tags' => $metadatas['tags']
+        );
+        $res = $this->_setMetadatas($id, $newMetadatas);
+        if (!$res) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Return an associative array of capabilities (booleans) of the backend
+     *
+     * The array must include these keys :
+     * - automatic_cleaning (is automating cleaning necessary)
+     * - tags (are tags supported)
+     * - expired_read (is it possible to read expired cache records
+     *                 (for doNotTestCacheValidity option for example))
+     * - priority does the backend deal with priority when saving
+     * - infinite_lifetime (is infinite lifetime can work with this backend)
+     * - get_list (is it possible to get the list of cache ids and the complete list of tags)
+     *
+     * @return array associative of with capabilities
+     */
+    public function getCapabilities()
+    {
+        return array(
+            'automatic_cleaning' => true,
+            'tags' => true,
+            'expired_read' => true,
+            'priority' => false,
+            'infinite_lifetime' => true,
+            'get_list' => true
+        );
+    }
+
+    /**
+     * PUBLIC METHOD FOR UNIT TESTING ONLY !
+     *
+     * Force a cache record to expire
+     *
+     * @param string $id cache id
+     */
+    public function ___expire($id)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if ($metadatas) {
+            $metadatas['expire'] = 1;
+            $this->_setMetadatas($id, $metadatas);
+        }
+    }
+
+    /**
+     * Get a metadatas record
+     *
+     * @param  string $id  Cache id
+     * @return array|false Associative array of metadatas
+     */
+    protected function _getMetadatas($id)
+    {
+        if (isset($this->_metadatasArray[$id])) {
+            return $this->_metadatasArray[$id];
+        } else {
+            $metadatas = $this->_loadMetadatas($id);
+            if (!$metadatas) {
+                return false;
+            }
+            $this->_setMetadatas($id, $metadatas, false);
+            return $metadatas;
+        }
+    }
+
+    /**
+     * Set a metadatas record
+     *
+     * @param  string $id        Cache id
+     * @param  array  $metadatas Associative array of metadatas
+     * @param  boolean $save     optional pass false to disable saving to file
+     * @return boolean True if no problem
+     */
+    protected function _setMetadatas($id, $metadatas, $save = true)
+    {
+        if (count($this->_metadatasArray) >= $this->_options['metadatas_array_max_size']) {
+            $n = (int) ($this->_options['metadatas_array_max_size'] / 10);
+            $this->_metadatasArray = array_slice($this->_metadatasArray, $n);
+        }
+        if ($save) {
+            $result = $this->_saveMetadatas($id, $metadatas);
+            if (!$result) {
+                return false;
+            }
+        }
+        $this->_metadatasArray[$id] = $metadatas;
+        return true;
+    }
+
+    /**
+     * Drop a metadata record
+     *
+     * @param  string $id Cache id
+     * @return boolean True if no problem
+     */
+    protected function _delMetadatas($id)
+    {
+        if (isset($this->_metadatasArray[$id])) {
+            unset($this->_metadatasArray[$id]);
+        }
+        $file = $this->_metadatasFile($id);
+        return $this->_remove($file);
+    }
+
+    /**
+     * Clear the metadatas array
+     *
+     * @return void
+     */
+    protected function _cleanMetadatas()
+    {
+        $this->_metadatasArray = array();
+    }
+
+    /**
+     * Load metadatas from disk
+     *
+     * @param  string $id Cache id
+     * @return array|false Metadatas associative array
+     */
+    protected function _loadMetadatas($id)
+    {
+        $file = $this->_metadatasFile($id);
+        $result = $this->_fileGetContents($file);
+        if (!$result) {
+            return false;
+        }
+        $tmp = @unserialize($result);
+        return $tmp;
+    }
+
+    /**
+     * Save metadatas to disk
+     *
+     * @param  string $id        Cache id
+     * @param  array  $metadatas Associative array
+     * @return boolean True if no problem
+     */
+    protected function _saveMetadatas($id, $metadatas)
+    {
+        $file = $this->_metadatasFile($id);
+        $result = $this->_filePutContents($file, serialize($metadatas));
+        if (!$result) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Make and return a file name (with path) for metadatas
+     *
+     * @param  string $id Cache id
+     * @return string Metadatas file name (with path)
+     */
+    protected function _metadatasFile($id)
+    {
+        $path = $this->_path($id);
+        $fileName = $this->_idToFileName('internal-metadatas---' . $id);
+        return $path . $fileName;
+    }
+
+    /**
+     * Check if the given filename is a metadatas one
+     *
+     * @param  string $fileName File name
+     * @return boolean True if it's a metadatas one
+     */
+    protected function _isMetadatasFile($fileName)
+    {
+        $id = $this->_fileNameToId($fileName);
+        if (substr($id, 0, 21) == 'internal-metadatas---') {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Remove a file
+     *
+     * If we can't remove the file (because of locks or any problem), we will touch
+     * the file to invalidate it
+     *
+     * @param  string $file Complete file path
+     * @return boolean True if ok
+     */
+    protected function _remove($file)
+    {
+        if (!is_file($file)) {
+            return false;
+        }
+        if (!@unlink($file)) {
+            # we can't remove the file (because of locks or any problem)
+            $this->_log("Zend_Cache_Backend_File::_remove() : we can't remove $file");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Clean some cache records (protected method used for recursive stuff)
+     *
+     * Available modes are :
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param  string $dir  Directory to clean
+     * @param  string $mode Clean mode
+     * @param  array  $tags Array of tags
+     * @throws Zend_Cache_Exception
+     * @return boolean True if no problem
+     */
+    protected function _clean($dir, $mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
+    {
+        if (!is_dir($dir)) {
+            return false;
+        }
+        $result = true;
+        $prefix = $this->_options['file_name_prefix'];
+        $glob = @glob($dir . $prefix . '--*');
+        if ($glob === false) {
+            // On some systems it is impossible to distinguish between empty match and an error.
+            return true;
+        }
+        foreach ($glob as $file)  {
+            if (is_file($file)) {
+                $fileName = basename($file);
+                if ($this->_isMetadatasFile($fileName)) {
+                    // in CLEANING_MODE_ALL, we drop anything, even remainings old metadatas files
+                    if ($mode != Zend_Cache::CLEANING_MODE_ALL) {
+                        continue;
+                    }
+                }
+                $id = $this->_fileNameToId($fileName);
+                $metadatas = $this->_getMetadatas($id);
+                if ($metadatas === FALSE) {
+                    $metadatas = array('expire' => 1, 'tags' => array());
+                }
+                switch ($mode) {
+                    case Zend_Cache::CLEANING_MODE_ALL:
+                        $res = $this->remove($id);
+                        if (!$res) {
+                            // in this case only, we accept a problem with the metadatas file drop
+                            $res = $this->_remove($file);
+                        }
+                        $result = $result && $res;
+                        break;
+                    case Zend_Cache::CLEANING_MODE_OLD:
+                        if (time() > $metadatas['expire']) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
+                        $matching = true;
+                        foreach ($tags as $tag) {
+                            if (!in_array($tag, $metadatas['tags'])) {
+                                $matching = false;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if (!$matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    default:
+                        Zend_Cache::throwException('Invalid mode for clean() method');
+                        break;
+                }
+            }
+            if ((is_dir($file)) and ($this->_options['hashed_directory_level']>0)) {
+                // Recursive call
+                $result = $this->_clean($file . DIRECTORY_SEPARATOR, $mode, $tags) && $result;
+                if ($mode == Zend_Cache::CLEANING_MODE_ALL) {
+                    // we try to drop the structure too
+                    @rmdir($file);
+                }
+            }
+        }
+        return $result;
+    }
+
+    protected function _get($dir, $mode, $tags = array())
+    {
+        if (!is_dir($dir)) {
+            return false;
+        }
+        $result = array();
+        $prefix = $this->_options['file_name_prefix'];
+        $glob = @glob($dir . $prefix . '--*');
+        if ($glob === false) {
+            // On some systems it is impossible to distinguish between empty match and an error.
+            return array();
+        }
+        foreach ($glob as $file)  {
+            if (is_file($file)) {
+                $fileName = basename($file);
+                $id = $this->_fileNameToId($fileName);
+                $metadatas = $this->_getMetadatas($id);
+                if ($metadatas === FALSE) {
+                    continue;
+                }
+                if (time() > $metadatas['expire']) {
+                    continue;
+                }
+                switch ($mode) {
+                    case 'ids':
+                        $result[] = $id;
+                        break;
+                    case 'tags':
+                        $result = array_unique(array_merge($result, $metadatas['tags']));
+                        break;
+                    case 'matching':
+                        $matching = true;
+                        foreach ($tags as $tag) {
+                            if (!in_array($tag, $metadatas['tags'])) {
+                                $matching = false;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    case 'notMatching':
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if (!$matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    case 'matchingAny':
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    default:
+                        Zend_Cache::throwException('Invalid mode for _get() method');
+                        break;
+                }
+            }
+            if ((is_dir($file)) and ($this->_options['hashed_directory_level']>0)) {
+                // Recursive call
+                $recursiveRs =  $this->_get($file . DIRECTORY_SEPARATOR, $mode, $tags);
+                if ($recursiveRs === false) {
+                    $this->_log('Zend_Cache_Backend_File::_get() / recursive call : can\'t list entries of "'.$file.'"');
+                } else {
+                    $result = array_unique(array_merge($result, $recursiveRs));
+                }
+            }
+        }
+        return array_unique($result);
+    }
+
+    /**
+     * Compute & return the expire time
+     *
+     * @return int expire time (unix timestamp)
+     */
+    protected function _expireTime($lifetime)
+    {
+        if ($lifetime === null) {
+            return 9999999999;
+        }
+        return time() + $lifetime;
+    }
+
+    /**
+     * Make a control key with the string containing datas
+     *
+     * @param  string $data        Data
+     * @param  string $controlType Type of control 'md5', 'crc32' or 'strlen'
+     * @throws Zend_Cache_Exception
+     * @return string Control key
+     */
+    protected function _hash($data, $controlType)
+    {
+        switch ($controlType) {
+        case 'md5':
+            return md5($data);
+        case 'crc32':
+            return crc32($data);
+        case 'strlen':
+            return strlen($data);
+        case 'adler32':
+            return hash('adler32', $data);
+        default:
+            Zend_Cache::throwException("Incorrect hash function : $controlType");
+        }
+    }
+
+    /**
+     * Transform a cache id into a file name and return it
+     *
+     * @param  string $id Cache id
+     * @return string File name
+     */
+    protected function _idToFileName($id)
+    {
+        $prefix = $this->_options['file_name_prefix'];
+        $result = $prefix . '---' . $id;
+        return $result;
+    }
+
+    /**
+     * Make and return a file name (with path)
+     *
+     * @param  string $id Cache id
+     * @return string File name (with path)
+     */
+    protected function _file($id)
+    {
+        $path = $this->_path($id);
+        $fileName = $this->_idToFileName($id);
+        return $path . $fileName;
+    }
+
+    /**
+     * Return the complete directory path of a filename (including hashedDirectoryStructure)
+     *
+     * @param  string $id Cache id
+     * @param  boolean $parts if true, returns array of directory parts instead of single string
+     * @return string Complete directory path
+     */
+    protected function _path($id, $parts = false)
+    {
+        $partsArray = array();
+        $root = $this->_options['cache_dir'];
+        $prefix = $this->_options['file_name_prefix'];
+        if ($this->_options['hashed_directory_level']>0) {
+            $hash = hash('adler32', $id);
+            for ($i=0 ; $i < $this->_options['hashed_directory_level'] ; $i++) {
+                $root = $root . $prefix . '--' . substr($hash, 0, $i + 1) . DIRECTORY_SEPARATOR;
+                $partsArray[] = $root;
+            }
+        }
+        if ($parts) {
+            return $partsArray;
+        } else {
+            return $root;
+        }
+    }
+
+    /**
+     * Make the directory strucuture for the given id
+     *
+     * @param string $id cache id
+     * @return boolean true
+     */
+    protected function _recursiveMkdirAndChmod($id)
+    {
+        if ($this->_options['hashed_directory_level'] <=0) {
+            return true;
+        }
+        $partsArray = $this->_path($id, true);
+        foreach ($partsArray as $part) {
+            if (!is_dir($part)) {
+                @mkdir($part, $this->_options['hashed_directory_perm']);
+                @chmod($part, $this->_options['hashed_directory_perm']); // see #ZF-320 (this line is required in some configurations)
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Test if the given cache id is available (and still valid as a cache record)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @return boolean|mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    protected function _test($id, $doNotTestCacheValidity)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if ($doNotTestCacheValidity || (time() <= $metadatas['expire'])) {
+            return $metadatas['mtime'];
+        }
+        return false;
+    }
+
+    /**
+     * Return the file content of the given file
+     *
+     * @param  string $file File complete path
+     * @return string File content (or false if problem)
+     */
+    protected function _fileGetContents($file)
+    {
+        $result = false;
+        if (!is_file($file)) {
+            return false;
+        }
+        $f = @fopen($file, 'rb');
+        if ($f) {
+            if ($this->_options['file_locking']) @flock($f, LOCK_SH);
+            $result = stream_get_contents($f);
+            if ($this->_options['file_locking']) @flock($f, LOCK_UN);
+            @fclose($f);
+        }
+        return $result;
+    }
+
+    /**
+     * Put the given string into the given file
+     *
+     * @param  string $file   File complete path
+     * @param  string $string String to put in file
+     * @return boolean true if no problem
+     */
+    protected function _filePutContents($file, $string)
+    {
+        $result = false;
+        $f = @fopen($file, 'ab+');
+        if ($f) {
+            if ($this->_options['file_locking']) @flock($f, LOCK_EX);
+            fseek($f, 0);
+            ftruncate($f, 0);
+            $tmp = @fwrite($f, $string);
+            if (!($tmp === FALSE)) {
+                $result = true;
+            }
+            @fclose($f);
+        }
+        @chmod($file, $this->_options['cache_file_perm']);
+        return $result;
+    }
+
+    /**
+     * Transform a file name into cache id and return it
+     *
+     * @param  string $fileName File name
+     * @return string Cache id
+     */
+    protected function _fileNameToId($fileName)
+    {
+        $prefix = $this->_options['file_name_prefix'];
+        return preg_replace('~^' . $prefix . '---(.*)$~', '$1', $fileName);
+    }
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php b/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php
new file mode 100644
index 00000000..3f44e2e1
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php
@@ -0,0 +1,99 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Interface.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+interface Zend_Cache_Backend_Interface
+{
+    /**
+     * Set the frontend directives
+     *
+     * @param array $directives assoc of directives
+     */
+    public function setDirectives($directives);
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * Note : return value is always "string" (unserialization is done by the core not by the backend)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @return string|false cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false);
+
+    /**
+     * Test if a cache is available or not (for the given id)
+     *
+     * @param  string $id cache id
+     * @return mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    public function test($id);
+
+    /**
+     * Save some string datas into a cache record
+     *
+     * Note : $data is always "string" (serialization is done by the
+     * core not by the backend)
+     *
+     * @param  string $data            Datas to cache
+     * @param  string $id              Cache id
+     * @param  array $tags             Array of strings, the cache record will be tagged by each string entry
+     * @param  int   $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @return boolean true if no problem
+     */
+    public function save($data, $id, $tags = array(), $specificLifetime = false);
+
+    /**
+     * Remove a cache record
+     *
+     * @param  string $id Cache id
+     * @return boolean True if no problem
+     */
+    public function remove($id);
+
+    /**
+     * Clean some cache records
+     *
+     * Available modes are :
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param  string $mode Clean mode
+     * @param  array  $tags Array of tags
+     * @return boolean true if no problem
+     */
+    public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array());
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Core.php b/inc/3rdparty/libraries/Zend/Cache/Core.php
new file mode 100644
index 00000000..e3588636
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Core.php
@@ -0,0 +1,765 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Core.php 24989 2012-06-21 07:24:13Z mabe $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Core
+{
+    /**
+     * Messages
+     */
+    const BACKEND_NOT_SUPPORTS_TAG = 'tags are not supported by the current backend';
+    const BACKEND_NOT_IMPLEMENTS_EXTENDED_IF = 'Current backend doesn\'t implement the Zend_Cache_Backend_ExtendedInterface, so this method is not available';
+
+    /**
+     * Backend Object
+     *
+     * @var Zend_Cache_Backend_Interface $_backend
+     */
+    protected $_backend = null;
+
+    /**
+     * Available options
+     *
+     * ====> (boolean) write_control :
+     * - Enable / disable write control (the cache is read just after writing to detect corrupt entries)
+     * - Enable write control will lightly slow the cache writing but not the cache reading
+     * Write control can detect some corrupt cache files but maybe it's not a perfect control
+     *
+     * ====> (boolean) caching :
+     * - Enable / disable caching
+     * (can be very useful for the debug of cached scripts)
+     *
+     * =====> (string) cache_id_prefix :
+     * - prefix for cache ids (namespace)
+     *
+     * ====> (boolean) automatic_serialization :
+     * - Enable / disable automatic serialization
+     * - It can be used to save directly datas which aren't strings (but it's slower)
+     *
+     * ====> (int) automatic_cleaning_factor :
+     * - Disable / Tune the automatic cleaning process
+     * - The automatic cleaning process destroy too old (for the given life time)
+     *   cache files when a new cache file is written :
+     *     0               => no automatic cache cleaning
+     *     1               => systematic cache cleaning
+     *     x (integer) > 1 => automatic cleaning randomly 1 times on x cache write
+     *
+     * ====> (int) lifetime :
+     * - Cache lifetime (in seconds)
+     * - If null, the cache is valid forever.
+     *
+     * ====> (boolean) logging :
+     * - If set to true, logging is activated (but the system is slower)
+     *
+     * ====> (boolean) ignore_user_abort
+     * - If set to true, the core will set the ignore_user_abort PHP flag inside the
+     *   save() method to avoid cache corruptions in some cases (default false)
+     *
+     * @var array $_options available options
+     */
+    protected $_options = array(
+        'write_control'             => true,
+        'caching'                   => true,
+        'cache_id_prefix'           => null,
+        'automatic_serialization'   => false,
+        'automatic_cleaning_factor' => 10,
+        'lifetime'                  => 3600,
+        'logging'                   => false,
+        'logger'                    => null,
+        'ignore_user_abort'         => false
+    );
+
+    /**
+     * Array of options which have to be transfered to backend
+     *
+     * @var array $_directivesList
+     */
+    protected static $_directivesList = array('lifetime', 'logging', 'logger');
+
+    /**
+     * Not used for the core, just a sort a hint to get a common setOption() method (for the core and for frontends)
+     *
+     * @var array $_specificOptions
+     */
+    protected $_specificOptions = array();
+
+    /**
+     * Last used cache id
+     *
+     * @var string $_lastId
+     */
+    private $_lastId = null;
+
+    /**
+     * True if the backend implements Zend_Cache_Backend_ExtendedInterface
+     *
+     * @var boolean $_extendedBackend
+     */
+    protected $_extendedBackend = false;
+
+    /**
+     * Array of capabilities of the backend (only if it implements Zend_Cache_Backend_ExtendedInterface)
+     *
+     * @var array
+     */
+    protected $_backendCapabilities = array();
+
+    /**
+     * Constructor
+     *
+     * @param  array|Zend_Config $options Associative array of options or Zend_Config instance
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct($options = array())
+    {
+        if ($options instanceof Zend_Config) {
+            $options = $options->toArray();
+        }
+        if (!is_array($options)) {
+            Zend_Cache::throwException("Options passed were not an array"
+            . " or Zend_Config instance.");
+        }
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+        $this->_loggerSanity();
+    }
+
+    /**
+     * Set options using an instance of type Zend_Config
+     *
+     * @param Zend_Config $config
+     * @return Zend_Cache_Core
+     */
+    public function setConfig(Zend_Config $config)
+    {
+        $options = $config->toArray();
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+        return $this;
+    }
+
+    /**
+     * Set the backend
+     *
+     * @param  Zend_Cache_Backend $backendObject
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setBackend(Zend_Cache_Backend $backendObject)
+    {
+        $this->_backend= $backendObject;
+        // some options (listed in $_directivesList) have to be given
+        // to the backend too (even if they are not "backend specific")
+        $directives = array();
+        foreach (Zend_Cache_Core::$_directivesList as $directive) {
+            $directives[$directive] = $this->_options[$directive];
+        }
+        $this->_backend->setDirectives($directives);
+        if (in_array('Zend_Cache_Backend_ExtendedInterface', class_implements($this->_backend))) {
+            $this->_extendedBackend = true;
+            $this->_backendCapabilities = $this->_backend->getCapabilities();
+        }
+
+    }
+
+    /**
+     * Returns the backend
+     *
+     * @return Zend_Cache_Backend backend object
+     */
+    public function getBackend()
+    {
+        return $this->_backend;
+    }
+
+    /**
+     * Public frontend to set an option
+     *
+     * There is an additional validation (relatively to the protected _setOption method)
+     *
+     * @param  string $name  Name of the option
+     * @param  mixed  $value Value of the option
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setOption($name, $value)
+    {
+        if (!is_string($name)) {
+            Zend_Cache::throwException("Incorrect option name!");
+        }
+        $name = strtolower($name);
+        if (array_key_exists($name, $this->_options)) {
+            // This is a Core option
+            $this->_setOption($name, $value);
+            return;
+        }
+        if (array_key_exists($name, $this->_specificOptions)) {
+            // This a specic option of this frontend
+            $this->_specificOptions[$name] = $value;
+            return;
+        }
+    }
+
+    /**
+     * Public frontend to get an option value
+     *
+     * @param  string $name  Name of the option
+     * @throws Zend_Cache_Exception
+     * @return mixed option value
+     */
+    public function getOption($name)
+    {
+        $name = strtolower($name);
+
+        if (array_key_exists($name, $this->_options)) {
+            // This is a Core option
+            return $this->_options[$name];
+        }
+
+        if (array_key_exists($name, $this->_specificOptions)) {
+            // This a specic option of this frontend
+            return $this->_specificOptions[$name];
+        }
+
+        Zend_Cache::throwException("Incorrect option name : $name");
+    }
+
+    /**
+     * Set an option
+     *
+     * @param  string $name  Name of the option
+     * @param  mixed  $value Value of the option
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    private function _setOption($name, $value)
+    {
+        if (!is_string($name) || !array_key_exists($name, $this->_options)) {
+            Zend_Cache::throwException("Incorrect option name : $name");
+        }
+        if ($name == 'lifetime' && empty($value)) {
+            $value = null;
+        }
+        $this->_options[$name] = $value;
+    }
+
+    /**
+     * Force a new lifetime
+     *
+     * The new value is set for the core/frontend but for the backend too (directive)
+     *
+     * @param  int $newLifetime New lifetime (in seconds)
+     * @return void
+     */
+    public function setLifetime($newLifetime)
+    {
+        $this->_options['lifetime'] = $newLifetime;
+        $this->_backend->setDirectives(array(
+            'lifetime' => $newLifetime
+        ));
+    }
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @param  boolean $doNotUnserialize       Do not serialize (even if automatic_serialization is true) => for internal use
+     * @return mixed|false Cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false, $doNotUnserialize = false)
+    {
+        if (!$this->_options['caching']) {
+            return false;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        $this->_lastId = $id;
+        self::_validateIdOrTag($id);
+
+        $this->_log("Zend_Cache_Core: load item '{$id}'", 7);
+        $data = $this->_backend->load($id, $doNotTestCacheValidity);
+        if ($data===false) {
+            // no cache available
+            return false;
+        }
+        if ((!$doNotUnserialize) && $this->_options['automatic_serialization']) {
+            // we need to unserialize before sending the result
+            return unserialize($data);
+        }
+        return $data;
+    }
+
+    /**
+     * Test if a cache is available for the given id
+     *
+     * @param  string $id Cache id
+     * @return int|false Last modified time of cache entry if it is available, false otherwise
+     */
+    public function test($id)
+    {
+        if (!$this->_options['caching']) {
+            return false;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        self::_validateIdOrTag($id);
+        $this->_lastId = $id;
+
+        $this->_log("Zend_Cache_Core: test item '{$id}'", 7);
+        return $this->_backend->test($id);
+    }
+
+    /**
+     * Save some data in a cache
+     *
+     * @param  mixed $data           Data to put in cache (can be another type than string if automatic_serialization is on)
+     * @param  string $id             Cache id (if not set, the last cache id will be used)
+     * @param  array $tags           Cache tags
+     * @param  int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @param  int   $priority         integer between 0 (very low priority) and 10 (maximum priority) used by some particular backends
+     * @throws Zend_Cache_Exception
+     * @return boolean True if no problem
+     */
+    public function save($data, $id = null, $tags = array(), $specificLifetime = false, $priority = 8)
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        if ($id === null) {
+            $id = $this->_lastId;
+        } else {
+            $id = $this->_id($id);
+        }
+        self::_validateIdOrTag($id);
+        self::_validateTagsArray($tags);
+        if ($this->_options['automatic_serialization']) {
+            // we need to serialize datas before storing them
+            $data = serialize($data);
+        } else {
+            if (!is_string($data)) {
+                Zend_Cache::throwException("Datas must be string or set automatic_serialization = true");
+            }
+        }
+
+        // automatic cleaning
+        if ($this->_options['automatic_cleaning_factor'] > 0) {
+            $rand = rand(1, $this->_options['automatic_cleaning_factor']);
+            if ($rand==1) {
+                //  new way                 || deprecated way
+                if ($this->_extendedBackend || method_exists($this->_backend, 'isAutomaticCleaningAvailable')) {
+                    $this->_log("Zend_Cache_Core::save(): automatic cleaning running", 7);
+                    $this->clean(Zend_Cache::CLEANING_MODE_OLD);
+                } else {
+                    $this->_log("Zend_Cache_Core::save(): automatic cleaning is not available/necessary with current backend", 4);
+                }
+            }
+        }
+
+        $this->_log("Zend_Cache_Core: save item '{$id}'", 7);
+        if ($this->_options['ignore_user_abort']) {
+            $abort = ignore_user_abort(true);
+        }
+        if (($this->_extendedBackend) && ($this->_backendCapabilities['priority'])) {
+            $result = $this->_backend->save($data, $id, $tags, $specificLifetime, $priority);
+        } else {
+            $result = $this->_backend->save($data, $id, $tags, $specificLifetime);
+        }
+        if ($this->_options['ignore_user_abort']) {
+            ignore_user_abort($abort);
+        }
+
+        if (!$result) {
+            // maybe the cache is corrupted, so we remove it !
+            $this->_log("Zend_Cache_Core::save(): failed to save item '{$id}' -> removing it", 4);
+            $this->_backend->remove($id);
+            return false;
+        }
+
+        if ($this->_options['write_control']) {
+            $data2 = $this->_backend->load($id, true);
+            if ($data!=$data2) {
+                $this->_log("Zend_Cache_Core::save(): write control of item '{$id}' failed -> removing it", 4);
+                $this->_backend->remove($id);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Remove a cache
+     *
+     * @param  string $id Cache id to remove
+     * @return boolean True if ok
+     */
+    public function remove($id)
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        self::_validateIdOrTag($id);
+
+        $this->_log("Zend_Cache_Core: remove item '{$id}'", 7);
+        return $this->_backend->remove($id);
+    }
+
+    /**
+     * Clean cache entries
+     *
+     * Available modes are :
+     * 'all' (default)  => remove all cache entries ($tags is not used)
+     * 'old'            => remove too old cache entries ($tags is not used)
+     * 'matchingTag'    => remove cache entries matching all given tags
+     *                     ($tags can be an array of strings or a single string)
+     * 'notMatchingTag' => remove cache entries not matching one of the given tags
+     *                     ($tags can be an array of strings or a single string)
+     * 'matchingAnyTag' => remove cache entries matching any given tags
+     *                     ($tags can be an array of strings or a single string)
+     *
+     * @param  string       $mode
+     * @param  array|string $tags
+     * @throws Zend_Cache_Exception
+     * @return boolean True if ok
+     */
+    public function clean($mode = 'all', $tags = array())
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        if (!in_array($mode, array(Zend_Cache::CLEANING_MODE_ALL,
+                                   Zend_Cache::CLEANING_MODE_OLD,
+                                   Zend_Cache::CLEANING_MODE_MATCHING_TAG,
+                                   Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG,
+                                   Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG))) {
+            Zend_Cache::throwException('Invalid cleaning mode');
+        }
+        self::_validateTagsArray($tags);
+
+        return $this->_backend->clean($mode, $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsMatchingTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsNotMatchingTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching any cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsMatchingAnyTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+
+        $ids = $this->_backend->getIds();
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+        return $this->_backend->getTags();
+    }
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        return $this->_backend->getFillingPercentage();
+    }
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array will include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id)
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        return $this->_backend->getMetadatas($id);
+    }
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime)
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        $id = $this->_id($id); // cache id may need prefix
+
+        $this->_log("Zend_Cache_Core: touch item '{$id}'", 7);
+        return $this->_backend->touch($id, $extraLifetime);
+    }
+
+    /**
+     * Validate a cache id or a tag (security, reliable filenames, reserved prefixes...)
+     *
+     * Throw an exception if a problem is found
+     *
+     * @param  string $string Cache id or tag
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected static function _validateIdOrTag($string)
+    {
+        if (!is_string($string)) {
+            Zend_Cache::throwException('Invalid id or tag : must be a string');
+        }
+        if (substr($string, 0, 9) == 'internal-') {
+            Zend_Cache::throwException('"internal-*" ids or tags are reserved');
+        }
+        if (!preg_match('~^[a-zA-Z0-9_]+$~D', $string)) {
+            Zend_Cache::throwException("Invalid id or tag '$string' : must use only [a-zA-Z0-9_]");
+        }
+    }
+
+    /**
+     * Validate a tags array (security, reliable filenames, reserved prefixes...)
+     *
+     * Throw an exception if a problem is found
+     *
+     * @param  array $tags Array of tags
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected static function _validateTagsArray($tags)
+    {
+        if (!is_array($tags)) {
+            Zend_Cache::throwException('Invalid tags array : must be an array');
+        }
+        foreach($tags as $tag) {
+            self::_validateIdOrTag($tag);
+        }
+        reset($tags);
+    }
+
+    /**
+     * Make sure if we enable logging that the Zend_Log class
+     * is available.
+     * Create a default log object if none is set.
+     *
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _loggerSanity()
+    {
+        if (!isset($this->_options['logging']) || !$this->_options['logging']) {
+            return;
+        }
+
+        if (isset($this->_options['logger']) && $this->_options['logger'] instanceof Zend_Log) {
+            return;
+        }
+
+        // Create a default logger to the standard output stream
+        require_once 'Zend/Log.php';
+        require_once 'Zend/Log/Writer/Stream.php';
+        require_once 'Zend/Log/Filter/Priority.php';
+        $logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
+        $logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
+        $this->_options['logger'] = $logger;
+    }
+
+    /**
+     * Log a message at the WARN (4) priority.
+     *
+     * @param string $message
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _log($message, $priority = 4)
+    {
+        if (!$this->_options['logging']) {
+            return;
+        }
+        if (!(isset($this->_options['logger']) || $this->_options['logger'] instanceof Zend_Log)) {
+            Zend_Cache::throwException('Logging is enabled but logger is not set');
+        }
+        $logger = $this->_options['logger'];
+        $logger->log($message, $priority);
+    }
+
+    /**
+     * Make and return a cache id
+     *
+     * Checks 'cache_id_prefix' and returns new id with prefix or simply the id if null
+     *
+     * @param  string $id Cache id
+     * @return string Cache id (with or without prefix)
+     */
+    protected function _id($id)
+    {
+        if (($id !== null) && isset($this->_options['cache_id_prefix'])) {
+            return $this->_options['cache_id_prefix'] . $id; // return with prefix
+        }
+        return $id; // no prefix, just return the $id passed
+    }
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Exception.php b/inc/3rdparty/libraries/Zend/Cache/Exception.php
new file mode 100644
index 00000000..44884515
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Exception.php
@@ -0,0 +1,32 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Exception.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+/**
+ * @see Zend_Exception
+ */
+require_once 'Zend/Exception.php';
+
+/**
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Exception extends Zend_Exception {}
diff --git a/inc/3rdparty/libraries/Zend/Exception.php b/inc/3rdparty/libraries/Zend/Exception.php
new file mode 100644
index 00000000..92b2e460
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Exception.php
@@ -0,0 +1,96 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Exception.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+/**
+* @category   Zend
+* @package    Zend
+* @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+* @license    http://framework.zend.com/license/new-bsd     New BSD License
+*/
+class Zend_Exception extends Exception
+{
+    /**
+     * @var null|Exception
+     */
+    private $_previous = null;
+
+    /**
+     * Construct the exception
+     *
+     * @param  string $msg
+     * @param  int $code
+     * @param  Exception $previous
+     * @return void
+     */
+    public function __construct($msg = '', $code = 0, Exception $previous = null)
+    {
+        if (version_compare(PHP_VERSION, '5.3.0', '<')) {
+            parent::__construct($msg, (int) $code);
+            $this->_previous = $previous;
+        } else {
+            parent::__construct($msg, (int) $code, $previous);
+        }
+    }
+
+    /**
+     * Overloading
+     *
+     * For PHP < 5.3.0, provides access to the getPrevious() method.
+     *
+     * @param  string $method
+     * @param  array $args
+     * @return mixed
+     */
+    public function __call($method, array $args)
+    {
+        if ('getprevious' == strtolower($method)) {
+            return $this->_getPrevious();
+        }
+        return null;
+    }
+
+    /**
+     * String representation of the exception
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        if (version_compare(PHP_VERSION, '5.3.0', '<')) {
+            if (null !== ($e = $this->getPrevious())) {
+                return $e->__toString()
+                       . "\n\nNext "
+                       . parent::__toString();
+            }
+        }
+        return parent::__toString();
+    }
+
+    /**
+     * Returns previous Exception
+     *
+     * @return Exception|null
+     */
+    protected function _getPrevious()
+    {
+        return $this->_previous;
+    }
+}
diff --git a/inc/3rdparty/libraries/content-extractor/ContentExtractor.php b/inc/3rdparty/libraries/content-extractor/ContentExtractor.php
new file mode 100644
index 00000000..ddd33bb5
--- /dev/null
+++ b/inc/3rdparty/libraries/content-extractor/ContentExtractor.php
@@ -0,0 +1,728 @@
+<?php

+/**

+ * Content Extractor

+ * 

+ * Uses patterns specified in site config files and auto detection (hNews/PHP Readability) 

+ * to extract content from HTML files.

+ * 

+ * @version 1.0

+ * @date 2013-02-05

+ * @author Keyvan Minoukadeh

+ * @copyright 2013 Keyvan Minoukadeh

+ * @license http://www.gnu.org/licenses/agpl-3.0.html AGPL v3

+ */

+

+class ContentExtractor

+{

+        protected static $tidy_config = array(

+                                 'clean' => true,

+                                 'output-xhtml' => true,

+                                 'logical-emphasis' => true,

+                                 'show-body-only' => false,

+                                 'new-blocklevel-tags' => 'article, aside, footer, header, hgroup, menu, nav, section, details, datagrid',

+                                 'new-inline-tags' => 'mark, time, meter, progress, data',

+                                 'wrap' => 0,

+                                 'drop-empty-paras' => true,

+                                 'drop-proprietary-attributes' => false,

+                                 'enclose-text' => true,

+                                 'enclose-block-text' => true,

+                                 'merge-divs' => true,

+                                 'merge-spans' => true,

+                                 'char-encoding' => 'utf8',

+                                 'hide-comments' => true

+                                 );

+        protected $html;

+        protected $config;

+        protected $title;

+        protected $author = array();

+        protected $language;

+        protected $date;

+        protected $body;

+        protected $success = false;

+        protected $nextPageUrl;

+        public $allowedParsers = array('libxml', 'html5lib');

+        public $fingerprints = array();

+        public $readability;

+        public $debug = false;

+        public $debugVerbose = false;

+

+        function __construct($path, $fallback=null) {

+                SiteConfig::set_config_path($path, $fallback);  

+        }

+        

+        protected function debug($msg) {

+                if ($this->debug) {

+                        $mem = round(memory_get_usage()/1024, 2);

+                        $memPeak = round(memory_get_peak_usage()/1024, 2);

+                        echo '* ',$msg;

+                        if ($this->debugVerbose) echo ' - mem used: ',$mem," (peak: $memPeak)";

+                        echo "\n";

+                        ob_flush();

+                        flush();

+                }

+        }

+        

+        public function reset() {

+                $this->html = null;

+                $this->readability = null;

+                $this->config = null;

+                $this->title = null;

+                $this->body = null;

+                $this->author = array();

+                $this->language = null;

+                $this->date = null;

+                $this->nextPageUrl = null;

+                $this->success = false;

+        }

+

+        public function findHostUsingFingerprints($html) {

+                $this->debug('Checking fingerprints...');

+                $head = substr($html, 0, 8000);

+                foreach ($this->fingerprints as $_fp => $_fphost) {

+                        $lookin = 'html';

+                        if (is_array($_fphost)) {

+                                if (isset($_fphost['head']) && $_fphost['head']) {

+                                        $lookin = 'head';

+                                }

+                                $_fphost = $_fphost['hostname'];

+                        }

+                        if (strpos($$lookin, $_fp) !== false) {

+                                $this->debug("Found match: $_fphost");

+                                return $_fphost;

+                        }

+                }

+                $this->debug('No fingerprint matches');

+                return false;

+        }

+        

+        // returns SiteConfig instance (joined in order: exact match, wildcard, fingerprint, global, default)

+        public function buildSiteConfig($url, $html='', $add_to_cache=true) {

+                // extract host name

+                $host = @parse_url($url, PHP_URL_HOST);

+                $host = strtolower($host);

+                if (substr($host, 0, 4) == 'www.') $host = substr($host, 4);

+                // is merged version already cached?

+                if (SiteConfig::is_cached("$host.merged")) {

+                        $this->debug("Returning cached and merged site config for $host");

+                        return SiteConfig::build("$host.merged");

+                }

+                // let's build from site_config/custom/ and standard/

+                $config = SiteConfig::build($host);

+                if ($add_to_cache && $config && !SiteConfig::is_cached("$host")) {

+                        SiteConfig::add_to_cache($host, $config);

+                }

+                // if no match, use defaults

+                if (!$config) $config = new SiteConfig();

+                // load fingerprint config?

+                if ($config->autodetect_on_failure()) {

+                        // check HTML for fingerprints

+                        if (!empty($this->fingerprints) && ($_fphost = $this->findHostUsingFingerprints($html))) {

+                                if ($config_fingerprint = SiteConfig::build($_fphost)) {

+                                        $this->debug("Appending site config settings from $_fphost (fingerprint match)");

+                                        $config->append($config_fingerprint);

+                                        if ($add_to_cache && !SiteConfig::is_cached($_fphost)) {

+                                                //$config_fingerprint->cache_in_apc = true;

+                                                SiteConfig::add_to_cache($_fphost, $config_fingerprint);

+                                        }

+                                }

+                        }

+                }

+                // load global config?

+                if ($config->autodetect_on_failure()) {

+                        if ($config_global = SiteConfig::build('global', true)) {

+                                $this->debug('Appending site config settings from global.txt');

+                                $config->append($config_global);

+                                if ($add_to_cache && !SiteConfig::is_cached('global')) {

+                                        //$config_global->cache_in_apc = true;

+                                        SiteConfig::add_to_cache('global', $config_global);

+                                }

+                        }

+                }

+                // store copy of merged config

+                if ($add_to_cache) {

+                        // do not store in APC if wildcard match

+                        $use_apc = ($host == $config->cache_key);

+                        $config->cache_key = null;

+                        SiteConfig::add_to_cache("$host.merged", $config, $use_apc);

+                }

+                return $config;

+        }

+        

+        // returns true on success, false on failure

+        // $smart_tidy indicates that if tidy is used and no results are produced, we will

+        // try again without it. Tidy helps us deal with PHP's patchy HTML parsing most of the time

+        // but it has problems of its own which we try to avoid with this option.

+        public function process($html, $url, $smart_tidy=true) {

+                $this->reset();

+                $this->config = $this->buildSiteConfig($url, $html);

+                

+                // do string replacements

+                if (!empty($this->config->find_string)) {

+                        if (count($this->config->find_string) == count($this->config->replace_string)) {

+                                $html = str_replace($this->config->find_string, $this->config->replace_string, $html, $_count);

+                                $this->debug("Strings replaced: $_count (find_string and/or replace_string)");

+                        } else {

+                                $this->debug('Skipped string replacement - incorrect number of find-replace strings in site config');

+                        }

+                        unset($_count);

+                }

+                

+                // use tidy (if it exists)?

+                // This fixes problems with some sites which would otherwise

+                // trouble DOMDocument's HTML parsing. (Although sometimes it

+                // makes matters worse, which is why you can override it in site config files.)

+                $tidied = false;

+                if ($this->config->tidy() && function_exists('tidy_parse_string') && $smart_tidy) {

+                        $this->debug('Using Tidy');

+                        $tidy = tidy_parse_string($html, self::$tidy_config, 'UTF8');

+                        if (tidy_clean_repair($tidy)) {

+                                $original_html = $html;

+                                $tidied = true;

+                                $html = $tidy->value;

+                        }

+                        unset($tidy);

+                }

+                

+                // load and parse html

+                $_parser = $this->config->parser();

+                if (!in_array($_parser, $this->allowedParsers)) {

+                        $this->debug("HTML parser $_parser not listed, using libxml instead");

+                        $_parser = 'libxml';

+                }

+                $this->debug("Attempting to parse HTML with $_parser");

+                $this->readability = new Readability($html, $url, $_parser);

+                

+                // we use xpath to find elements in the given HTML document

+                // see http://en.wikipedia.org/wiki/XPath_1.0

+                $xpath = new DOMXPath($this->readability->dom);

+

+                // try to get next page link

+                foreach ($this->config->next_page_link as $pattern) {

+                        $elems = @$xpath->evaluate($pattern, $this->readability->dom);

+                        if (is_string($elems)) {

+                                $this->nextPageUrl = trim($elems);

+                                break;

+                        } elseif ($elems instanceof DOMNodeList && $elems->length > 0) {

+                                foreach ($elems as $item) {

+                                        if ($item instanceof DOMElement && $item->hasAttribute('href')) {

+                                                $this->nextPageUrl = $item->getAttribute('href');

+                                                break 2;

+                                        } elseif ($item instanceof DOMAttr && $item->value) {

+                                                $this->nextPageUrl = $item->value;

+                                                break 2;

+                                        }

+                                }

+                        }

+                }

+                

+                // try to get title

+                foreach ($this->config->title as $pattern) {

+                        // $this->debug("Trying $pattern");

+                        $elems = @$xpath->evaluate($pattern, $this->readability->dom);

+                        if (is_string($elems)) {

+                                $this->title = trim($elems);

+                                $this->debug('Title expression evaluated as string: '.$this->title);

+                                $this->debug("...XPath match: $pattern");

+                                break;

+                        } elseif ($elems instanceof DOMNodeList && $elems->length > 0) {

+                                $this->title = $elems->item(0)->textContent;

+                                $this->debug('Title matched: '.$this->title);

+                                $this->debug("...XPath match: $pattern");

+                                // remove title from document

+                                try {

+                                        $elems->item(0)->parentNode->removeChild($elems->item(0));

+                                } catch (DOMException $e) {

+                                        // do nothing

+                                }

+                                break;

+                        }

+                }

+                

+                // try to get author (if it hasn't already been set)

+                if (empty($this->author)) {

+                        foreach ($this->config->author as $pattern) {

+                                $elems = @$xpath->evaluate($pattern, $this->readability->dom);

+                                if (is_string($elems)) {

+                                        if (trim($elems) != '') {

+                                                $this->author[] = trim($elems);

+                                                $this->debug('Author expression evaluated as string: '.trim($elems));

+                                                $this->debug("...XPath match: $pattern");

+                                                break;

+                                        }

+                                } elseif ($elems instanceof DOMNodeList && $elems->length > 0) {

+                                        foreach ($elems as $elem) {

+                                                if (!isset($elem->parentNode)) continue;

+                                                $this->author[] = trim($elem->textContent);

+                                                $this->debug('Author matched: '.trim($elem->textContent));

+                                        }

+                                        if (!empty($this->author)) {

+                                                $this->debug("...XPath match: $pattern");

+                                                break;

+                                        }

+                                }

+                        }

+                }

+                

+                // try to get language

+                $_lang_xpath = array('//html[@lang]/@lang', '//meta[@name="DC.language"]/@content');

+                foreach ($_lang_xpath as $pattern) {

+                        $elems = @$xpath->evaluate($pattern, $this->readability->dom);

+                        if (is_string($elems)) {

+                                if (trim($elems) != '') {

+                                        $this->language = trim($elems);

+                                        $this->debug('Language matched: '.$this->language);

+                                        break;

+                                }

+                        } elseif ($elems instanceof DOMNodeList && $elems->length > 0) {

+                                foreach ($elems as $elem) {

+                                        if (!isset($elem->parentNode)) continue;

+                                        $this->language = trim($elem->textContent);

+                                        $this->debug('Language matched: '.$this->language);                                     

+                                }

+                                if ($this->language) break;

+                        }

+                }

+                

+                // try to get date

+                foreach ($this->config->date as $pattern) {

+                        $elems = @$xpath->evaluate($pattern, $this->readability->dom);

+                        if (is_string($elems)) {

+                                $this->date = strtotime(trim($elems, "; \t\n\r\0\x0B"));                                

+                        } elseif ($elems instanceof DOMNodeList && $elems->length > 0) {

+                                $this->date = $elems->item(0)->textContent;

+                                $this->date = strtotime(trim($this->date, "; \t\n\r\0\x0B"));

+                                // remove date from document

+                                // $elems->item(0)->parentNode->removeChild($elems->item(0));

+                        }

+                        if (!$this->date) {

+                                $this->date = null;

+                        } else {

+                                $this->debug('Date matched: '.date('Y-m-d H:i:s', $this->date));

+                                $this->debug("...XPath match: $pattern");

+                                break;

+                        }

+                }

+

+                // strip elements (using xpath expressions)

+                foreach ($this->config->strip as $pattern) {

+                        $elems = @$xpath->query($pattern, $this->readability->dom);

+                        // check for matches

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('Stripping '.$elems->length.' elements (strip)');

+                                for ($i=$elems->length-1; $i >= 0; $i--) {

+                                        $elems->item($i)->parentNode->removeChild($elems->item($i));

+                                }

+                        }

+                }

+                

+                // strip elements (using id and class attribute values)

+                foreach ($this->config->strip_id_or_class as $string) {

+                        $string = strtr($string, array("'"=>'', '"'=>''));

+                        $elems = @$xpath->query("//*[contains(@class, '$string') or contains(@id, '$string')]", $this->readability->dom);

+                        // check for matches

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('Stripping '.$elems->length.' elements (strip_id_or_class)');

+                                for ($i=$elems->length-1; $i >= 0; $i--) {

+                                        $elems->item($i)->parentNode->removeChild($elems->item($i));

+                                }

+                        }

+                }

+                

+                // strip images (using src attribute values)

+                foreach ($this->config->strip_image_src as $string) {

+                        $string = strtr($string, array("'"=>'', '"'=>''));

+                        $elems = @$xpath->query("//img[contains(@src, '$string')]", $this->readability->dom);

+                        // check for matches

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('Stripping '.$elems->length.' image elements');

+                                for ($i=$elems->length-1; $i >= 0; $i--) {

+                                        $elems->item($i)->parentNode->removeChild($elems->item($i));

+                                }

+                        }

+                }

+                // strip elements using Readability.com and Instapaper.com ignore class names

+                // .entry-unrelated and .instapaper_ignore

+                // See https://www.readability.com/publishers/guidelines/#view-plainGuidelines

+                // and http://blog.instapaper.com/post/730281947

+                $elems = @$xpath->query("//*[contains(concat(' ',normalize-space(@class),' '),' entry-unrelated ') or contains(concat(' ',normalize-space(@class),' '),' instapaper_ignore ')]", $this->readability->dom);

+                // check for matches

+                if ($elems && $elems->length > 0) {

+                        $this->debug('Stripping '.$elems->length.' .entry-unrelated,.instapaper_ignore elements');

+                        for ($i=$elems->length-1; $i >= 0; $i--) {

+                                $elems->item($i)->parentNode->removeChild($elems->item($i));

+                        }

+                }

+                

+                // strip elements that contain style="display: none;"

+                $elems = @$xpath->query("//*[contains(@style,'display:none')]", $this->readability->dom);

+                // check for matches

+                if ($elems && $elems->length > 0) {

+                        $this->debug('Stripping '.$elems->length.' elements with inline display:none style');

+                        for ($i=$elems->length-1; $i >= 0; $i--) {

+                                $elems->item($i)->parentNode->removeChild($elems->item($i));

+                        }

+                }

+                

+                // try to get body

+                foreach ($this->config->body as $pattern) {

+                        $elems = @$xpath->query($pattern, $this->readability->dom);

+                        // check for matches

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('Body matched');

+                                $this->debug("...XPath match: $pattern");

+                                if ($elems->length == 1) {                              

+                                        $this->body = $elems->item(0);

+                                        // prune (clean up elements that may not be content)

+                                        if ($this->config->prune()) {

+                                                $this->debug('...pruning content');

+                                                $this->readability->prepArticle($this->body);

+                                        }

+                                        break;

+                                } else {

+                                        $this->body = $this->readability->dom->createElement('div');

+                                        $this->debug($elems->length.' body elems found');

+                                        foreach ($elems as $elem) {

+                                                if (!isset($elem->parentNode)) continue;

+                                                $isDescendant = false;

+                                                foreach ($this->body->childNodes as $parent) {

+                                                        if ($this->isDescendant($parent, $elem)) {

+                                                                $isDescendant = true;

+                                                                break;

+                                                        }

+                                                }

+                                                if ($isDescendant) {

+                                                        $this->debug('...element is child of another body element, skipping.');

+                                                } else {

+                                                        // prune (clean up elements that may not be content)

+                                                        if ($this->config->prune()) {

+                                                                $this->debug('Pruning content');

+                                                                $this->readability->prepArticle($elem);

+                                                        }

+                                                        $this->debug('...element added to body');

+                                                        $this->body->appendChild($elem);

+                                                }

+                                        }

+                                        if ($this->body->hasChildNodes()) break;

+                                }

+                        }

+                }               

+                

+                // auto detect?

+                $detect_title = $detect_body = $detect_author = $detect_date = false;

+                // detect title?

+                if (!isset($this->title)) {

+                        if (empty($this->config->title) || $this->config->autodetect_on_failure()) {

+                                $detect_title = true;

+                        }

+                }

+                // detect body?

+                if (!isset($this->body)) {

+                        if (empty($this->config->body) || $this->config->autodetect_on_failure()) {

+                                $detect_body = true;

+                        }

+                }

+                // detect author?

+                if (empty($this->author)) {

+                        if (empty($this->config->author) || $this->config->autodetect_on_failure()) {

+                                $detect_author = true;

+                        }

+                }

+                // detect date?

+                if (!isset($this->date)) {

+                        if (empty($this->config->date) || $this->config->autodetect_on_failure()) {

+                                $detect_date = true;

+                        }

+                }

+

+                // check for hNews

+                if ($detect_title || $detect_body) {

+                        // check for hentry

+                        $elems = @$xpath->query("//*[contains(concat(' ',normalize-space(@class),' '),' hentry ')]", $this->readability->dom);

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('hNews: found hentry');

+                                $hentry = $elems->item(0);

+                                

+                                if ($detect_title) {

+                                        // check for entry-title

+                                        $elems = @$xpath->query(".//*[contains(concat(' ',normalize-space(@class),' '),' entry-title ')]", $hentry);

+                                        if ($elems && $elems->length > 0) {

+                                                $this->title = $elems->item(0)->textContent;

+                                                $this->debug('hNews: found entry-title: '.$this->title);

+                                                // remove title from document

+                                                $elems->item(0)->parentNode->removeChild($elems->item(0));

+                                                $detect_title = false;

+                                        }

+                                }

+                                

+                                if ($detect_date) {

+                                        // check for time element with pubdate attribute

+                                        $elems = @$xpath->query(".//time[@pubdate] | .//abbr[contains(concat(' ',normalize-space(@class),' '),' published ')]", $hentry);

+                                        if ($elems && $elems->length > 0) {

+                                                $this->date = strtotime(trim($elems->item(0)->textContent));

+                                                // remove date from document

+                                                //$elems->item(0)->parentNode->removeChild($elems->item(0));

+                                                if ($this->date) {

+                                                        $this->debug('hNews: found publication date: '.date('Y-m-d H:i:s', $this->date));

+                                                        $detect_date = false;

+                                                } else {

+                                                        $this->date = null;

+                                                }

+                                        }

+                                }

+

+                                if ($detect_author) {

+                                        // check for time element with pubdate attribute

+                                        $elems = @$xpath->query(".//*[contains(concat(' ',normalize-space(@class),' '),' vcard ') and (contains(concat(' ',normalize-space(@class),' '),' author ') or contains(concat(' ',normalize-space(@class),' '),' byline '))]", $hentry);

+                                        if ($elems && $elems->length > 0) {

+                                                $author = $elems->item(0);

+                                                $fn = @$xpath->query(".//*[contains(concat(' ',normalize-space(@class),' '),' fn ')]", $author);

+                                                if ($fn && $fn->length > 0) {

+                                                        foreach ($fn as $_fn) {

+                                                                if (trim($_fn->textContent) != '') {

+                                                                        $this->author[] = trim($_fn->textContent);

+                                                                        $this->debug('hNews: found author: '.trim($_fn->textContent));

+                                                                }

+                                                        }

+                                                } else {

+                                                        if (trim($author->textContent) != '') {

+                                                                $this->author[] = trim($author->textContent);

+                                                                $this->debug('hNews: found author: '.trim($author->textContent));

+                                                        }

+                                                }

+                                                $detect_author = empty($this->author);

+                                        }

+                                }

+                                

+                                // check for entry-content.

+                                // according to hAtom spec, if there are multiple elements marked entry-content,

+                                // we include all of these in the order they appear - see http://microformats.org/wiki/hatom#Entry_Content

+                                if ($detect_body) {

+                                        $elems = @$xpath->query(".//*[contains(concat(' ',normalize-space(@class),' '),' entry-content ')]", $hentry);

+                                        if ($elems && $elems->length > 0) {

+                                                $this->debug('hNews: found entry-content');

+                                                if ($elems->length == 1) {

+                                                        // what if it's empty? (some sites misuse hNews - place their content outside an empty entry-content element)

+                                                        $e = $elems->item(0);

+                                                        if (($e->tagName == 'img') || (trim($e->textContent) != '')) {

+                                                                $this->body = $elems->item(0);

+                                                                // prune (clean up elements that may not be content)

+                                                                if ($this->config->prune()) {

+                                                                        $this->debug('Pruning content');

+                                                                        $this->readability->prepArticle($this->body);

+                                                                }

+                                                                $detect_body = false;

+                                                        } else {

+                                                                $this->debug('hNews: skipping entry-content - appears not to contain content');

+                                                        }

+                                                        unset($e);

+                                                } else {

+                                                        $this->body = $this->readability->dom->createElement('div');

+                                                        $this->debug($elems->length.' entry-content elems found');

+                                                        foreach ($elems as $elem) {

+                                                                if (!isset($elem->parentNode)) continue;

+                                                                $isDescendant = false;

+                                                                foreach ($this->body->childNodes as $parent) {

+                                                                        if ($this->isDescendant($parent, $elem)) {

+                                                                                $isDescendant = true;

+                                                                                break;

+                                                                        }

+                                                                }

+                                                                if ($isDescendant) {

+                                                                        $this->debug('Element is child of another body element, skipping.');

+                                                                } else {

+                                                                        // prune (clean up elements that may not be content)

+                                                                        if ($this->config->prune()) {

+                                                                                $this->debug('Pruning content');

+                                                                                $this->readability->prepArticle($elem);

+                                                                        }                                                               

+                                                                        $this->debug('Element added to body');                                                                  

+                                                                        $this->body->appendChild($elem);

+                                                                }

+                                                        }

+                                                        $detect_body = false;

+                                                }

+                                        }

+                                }

+                        }

+                }

+

+                // check for elements marked with instapaper_title

+                if ($detect_title) {

+                        // check for instapaper_title

+                        $elems = @$xpath->query("//*[contains(concat(' ',normalize-space(@class),' '),' instapaper_title ')]", $this->readability->dom);

+                        if ($elems && $elems->length > 0) {

+                                $this->title = $elems->item(0)->textContent;

+                                $this->debug('Title found (.instapaper_title): '.$this->title);

+                                // remove title from document

+                                $elems->item(0)->parentNode->removeChild($elems->item(0));

+                                $detect_title = false;

+                        }

+                }

+                // check for elements marked with instapaper_body

+                if ($detect_body) {

+                        $elems = @$xpath->query("//*[contains(concat(' ',normalize-space(@class),' '),' instapaper_body ')]", $this->readability->dom);

+                        if ($elems && $elems->length > 0) {

+                                $this->debug('body found (.instapaper_body)');

+                                $this->body = $elems->item(0);

+                                // prune (clean up elements that may not be content)

+                                if ($this->config->prune()) {

+                                        $this->debug('Pruning content');

+                                        $this->readability->prepArticle($this->body);

+                                }

+                                $detect_body = false;

+                        }

+                }

+                

+                // Find author in rel="author" marked element

+                // We only use this if there's exactly one.

+                // If there's more than one, it could indicate more than

+                // one author, but it could also indicate that we're processing

+                // a page listing different articles with different authors.

+                if ($detect_author) {

+                        $elems = @$xpath->query("//a[contains(concat(' ',normalize-space(@rel),' '),' author ')]", $this->readability->dom);

+                        if ($elems && $elems->length == 1) {

+                                $author = trim($elems->item(0)->textContent);

+                                if ($author != '') {

+                                        $this->debug("Author found (rel=\"author\"): $author");

+                                        $this->author[] = $author;

+                                        $detect_author = false;

+                                }

+                        }

+                }

+

+                // Find date in pubdate marked time element

+                // For the same reason given above, we only use this

+                // if there's exactly one element.

+                if ($detect_date) {

+                        $elems = @$xpath->query("//time[@pubdate]", $this->readability->dom);

+                        if ($elems && $elems->length == 1) {

+                                $this->date = strtotime(trim($elems->item(0)->textContent));

+                                // remove date from document

+                                //$elems->item(0)->parentNode->removeChild($elems->item(0));

+                                if ($this->date) {

+                                        $this->debug('Date found (pubdate marked time element): '.date('Y-m-d H:i:s', $this->date));

+                                        $detect_date = false;

+                                } else {

+                                        $this->date = null;

+                                }

+                        }

+                }

+

+                // still missing title or body, so we detect using Readability

+                if ($detect_title || $detect_body) {

+                        $this->debug('Using Readability');

+                        // clone body if we're only using Readability for title (otherwise it may interfere with body element)

+                        if (isset($this->body)) $this->body = $this->body->cloneNode(true);

+                        $success = $this->readability->init();

+                }

+                if ($detect_title) {

+                        $this->debug('Detecting title');

+                        $this->title = $this->readability->getTitle()->textContent;

+                }

+                if ($detect_body && $success) {

+                        $this->debug('Detecting body');

+                        $this->body = $this->readability->getContent();

+                        if ($this->body->childNodes->length == 1 && $this->body->firstChild->nodeType === XML_ELEMENT_NODE) {

+                                $this->body = $this->body->firstChild;

+                        }

+                        // prune (clean up elements that may not be content)

+                        if ($this->config->prune()) {

+                                $this->debug('Pruning content');

+                                $this->readability->prepArticle($this->body);

+                        }

+                }

+                if (isset($this->body)) {

+                        // remove scripts

+                        $this->readability->removeScripts($this->body);

+                        // remove any h1-h6 elements that appear as first thing in the body

+                        // and which match our title

+                        if (isset($this->title) && ($this->title != '')) {

+                                $firstChild = $this->body->firstChild;

+                                while ($firstChild->nodeType && ($firstChild->nodeType !== XML_ELEMENT_NODE)) {

+                                        $firstChild = $firstChild->nextSibling;

+                                }

+                                if (($firstChild->nodeType === XML_ELEMENT_NODE)

+                                        && in_array(strtolower($firstChild->tagName), array('h1', 'h2', 'h3', 'h4', 'h5', 'h6'))

+                                        && (strtolower(trim($firstChild->textContent)) == strtolower(trim($this->title)))) {

+                                                $this->body->removeChild($firstChild);

+                                }

+                        }

+                        // prevent self-closing iframes

+                        $elems = $this->body->getElementsByTagName('iframe');

+                        for ($i = $elems->length-1; $i >= 0; $i--) {

+                                $e = $elems->item($i);

+                                if (!$e->hasChildNodes()) {

+                                        $e->appendChild($this->body->ownerDocument->createTextNode('[embedded content]'));

+                                }

+                        }

+                        // remove image lazy loading - WordPress plugin http://wordpress.org/extend/plugins/lazy-load/

+                        // the plugin replaces the src attribute to point to a 1x1 gif and puts the original src

+                        // inside the data-lazy-src attribute. It also places the original image inside a noscript element 

+                        // next to the amended one.

+                        $elems = @$xpath->query("//img[@data-lazy-src]", $this->body);

+                        for ($i = $elems->length-1; $i >= 0; $i--) {

+                                $e = $elems->item($i);

+                                // let's see if we can grab image from noscript

+                                if ($e->nextSibling !== null && $e->nextSibling->nodeName === 'noscript') {

+                                        $_new_elem = $e->ownerDocument->createDocumentFragment();

+                                        @$_new_elem->appendXML($e->nextSibling->innerHTML);

+                                        $e->nextSibling->parentNode->replaceChild($_new_elem, $e->nextSibling);

+                                        $e->parentNode->removeChild($e);

+                                } else {

+                                        // Use data-lazy-src as src value

+                                        $e->setAttribute('src', $e->getAttribute('data-lazy-src'));

+                                        $e->removeAttribute('data-lazy-src');

+                                }

+                        }

+                

+                        $this->success = true;

+                }

+                

+                // if we've had no success and we've used tidy, there's a chance

+                // that tidy has messed up. So let's try again without tidy...

+                if (!$this->success && $tidied && $smart_tidy) {

+                        $this->debug('Trying again without tidy');

+                        $this->process($original_html, $url, false);

+                }

+

+                return $this->success;

+        }

+        

+        private function isDescendant(DOMElement $parent, DOMElement $child) {

+                $node = $child->parentNode;

+                while ($node != null) {

+                        if ($node->isSameNode($parent)) return true;

+                        $node = $node->parentNode;

+                }

+                return false;

+        }

+

+        public function getContent() {

+                return $this->body;

+        }

+        

+        public function getTitle() {

+                return $this->title;

+        }

+        

+        public function getAuthors() {

+                return $this->author;

+        }

+        

+        public function getLanguage() {

+                return $this->language;

+        }

+        

+        public function getDate() {

+                return $this->date;

+        }

+        

+        public function getSiteConfig() {

+                return $this->config;

+        }

+        

+        public function getNextPageUrl() {

+                return $this->nextPageUrl;

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/content-extractor/SiteConfig.php b/inc/3rdparty/libraries/content-extractor/SiteConfig.php
new file mode 100644
index 00000000..c5e300d7
--- /dev/null
+++ b/inc/3rdparty/libraries/content-extractor/SiteConfig.php
@@ -0,0 +1,338 @@
+<?php

+/**

+ * Site Config

+ * 

+ * Each instance of this class should hold extraction patterns and other directives

+ * for a website. See ContentExtractor class to see how it's used.

+ * 

+ * @version 0.7

+ * @date 2012-08-27

+ * @author Keyvan Minoukadeh

+ * @copyright 2012 Keyvan Minoukadeh

+ * @license http://www.gnu.org/licenses/agpl-3.0.html AGPL v3

+ */

+

+class SiteConfig

+{

+        // Use first matching element as title (0 or more xpath expressions)

+        public $title = array();

+        

+        // Use first matching element as body (0 or more xpath expressions)

+        public $body = array();

+        

+        // Use first matching element as author (0 or more xpath expressions)

+        public $author = array();

+        

+        // Use first matching element as date (0 or more xpath expressions)

+        public $date = array();

+        

+        // Strip elements matching these xpath expressions (0 or more)

+        public $strip = array();

+        

+        // Strip elements which contain these strings (0 or more) in the id or class attribute 

+        public $strip_id_or_class = array();

+        

+        // Strip images which contain these strings (0 or more) in the src attribute 

+        public $strip_image_src = array();

+        

+        // Additional HTTP headers to send

+        // NOT YET USED

+        public $http_header = array();

+        

+        // Process HTML with tidy before creating DOM (bool or null if undeclared)

+        public $tidy = null;

+        

+        protected $default_tidy = true; // used if undeclared

+        

+        // Autodetect title/body if xpath expressions fail to produce results.

+        // Note that this applies to title and body separately, ie. 

+        //   * if we get a body match but no title match, this option will determine whether we autodetect title 

+        //   * if neither match, this determines whether we autodetect title and body.

+        // Also note that this only applies when there is at least one xpath expression in title or body, ie.

+        //   * if title and body are both empty (no xpath expressions), this option has no effect (both title and body will be auto-detected)

+        //   * if there's an xpath expression for title and none for body, body will be auto-detected and this option will determine whether we auto-detect title if the xpath expression for it fails to produce results.

+        // Usage scenario: you want to extract something specific from a set of URLs, e.g. a table, and if the table is not found, you want to ignore the entry completely. Auto-detection is unlikely to succeed here, so you construct your patterns and set this option to false. Another scenario may be a site where auto-detection has proven to fail (or worse, picked up the wrong content).

+        // bool or null if undeclared

+        public $autodetect_on_failure = null;

+        protected $default_autodetect_on_failure = true; // used if undeclared

+        

+        // Clean up content block - attempt to remove elements that appear to be superfluous

+        // bool or null if undeclared

+        public $prune = null;

+        protected $default_prune = true; // used if undeclared

+        

+        // Test URL - if present, can be used to test the config above

+        public $test_url = array();

+        

+        // Single-page link - should identify a link element or URL pointing to the page holding the entire article

+        // This is useful for sites which split their articles across multiple pages. Links to such pages tend to 

+        // display the first page with links to the other pages at the bottom. Often there is also a link to a page

+        // which displays the entire article on one page (e.g. 'print view').

+        // This should be an XPath expression identifying the link to that page. If present and we find a match,

+        // we will retrieve that page and the rest of the options in this config will be applied to the new page.

+        public $single_page_link = array();

+        

+        public $next_page_link = array();

+        

+        // Single-page link in feed? - same as above, but patterns applied to item description HTML taken from feed

+        public $single_page_link_in_feed = array();

+        

+        // Which parser to use for turning raw HTML into a DOMDocument (either 'libxml' or 'html5lib')

+        // string or null if undeclared

+        public $parser = null;

+        protected $default_parser = 'libxml'; // used if undeclared

+        

+        // Strings to search for in HTML before processing begins (used with $replace_string)

+        public $find_string = array();

+        // Strings to replace those found in $find_string before HTML processing begins

+        public $replace_string = array();

+        

+        // the options below cannot be set in the config files which this class represents

+        

+        //public $cache_in_apc = false; // used to decide if we should cache in apc or not

+        public $cache_key = null;

+        public static $debug = false;

+        protected static $apc = false;

+        protected static $config_path;

+        protected static $config_path_fallback;

+        protected static $config_cache = array();

+        const HOSTNAME_REGEX = '/^(([a-zA-Z0-9-]*[a-zA-Z0-9])\.)*([A-Za-z0-9-]*[A-Za-z0-9])$/';

+        

+        protected static function debug($msg) {

+                if (self::$debug) {

+                        //$mem = round(memory_get_usage()/1024, 2);

+                        //$memPeak = round(memory_get_peak_usage()/1024, 2);

+                        echo '* ',$msg;

+                        //echo ' - mem used: ',$mem," (peak: $memPeak)\n";

+                        echo "\n";

+                        ob_flush();

+                        flush();

+                }

+        }

+        

+        // enable APC caching of certain site config files?

+        // If enabled the following site config files will be 

+        // cached in APC cache (when requested for first time):

+        // * anything in site_config/custom/ and its corresponding file in site_config/standard/

+        // * the site config files associated with HTML fingerprints

+        // * the global site config file

+        // returns true if enabled, false otherwise

+        public static function use_apc($apc=true) {

+                if (!function_exists('apc_add')) {

+                        if ($apc) self::debug('APC will not be used (function apc_add does not exist)');

+                        return false;

+                }

+                self::$apc = $apc;

+                return $apc;

+        }

+        

+        // return bool or null

+        public function tidy($use_default=true) {

+                if ($use_default) return (isset($this->tidy)) ? $this->tidy : $this->default_tidy;

+                return $this->tidy;

+        }

+        

+        // return bool or null

+        public function prune($use_default=true) {

+                if ($use_default) return (isset($this->prune)) ? $this->prune : $this->default_prune;

+                return $this->prune;

+        }

+        

+        // return string or null

+        public function parser($use_default=true) {

+                if ($use_default) return (isset($this->parser)) ? $this->parser : $this->default_parser;

+                return $this->parser;

+        }

+

+        // return bool or null

+        public function autodetect_on_failure($use_default=true) {

+                if ($use_default) return (isset($this->autodetect_on_failure)) ? $this->autodetect_on_failure : $this->default_autodetect_on_failure;

+                return $this->autodetect_on_failure;

+        }

+        

+        public static function set_config_path($path, $fallback=null) {

+                self::$config_path = $path;

+                self::$config_path_fallback = $fallback;

+        }

+        

+        public static function add_to_cache($key, SiteConfig $config, $use_apc=true) {

+                $key = strtolower($key);

+                if (substr($key, 0, 4) == 'www.') $key = substr($key, 4);

+                if ($config->cache_key) $key = $config->cache_key;

+                self::$config_cache[$key] = $config;

+                if (self::$apc && $use_apc) {

+                        self::debug("Adding site config to APC cache with key sc.$key");

+                        apc_add("sc.$key", $config);

+                }

+                self::debug("Cached site config with key $key");

+        }

+        

+        public static function is_cached($key) {

+                $key = strtolower($key);

+                if (substr($key, 0, 4) == 'www.') $key = substr($key, 4);

+                if (array_key_exists($key, self::$config_cache)) {

+                        return true;

+                } elseif (self::$apc && (bool)apc_fetch("sc.$key")) {

+                        return true;

+                }

+                return false;

+        }

+        

+        public function append(SiteConfig $newconfig) {

+                // check for commands where we accept multiple statements (no test_url)

+                foreach (array('title', 'body', 'author', 'date', 'strip', 'strip_id_or_class', 'strip_image_src', 'single_page_link', 'single_page_link_in_feed', 'next_page_link', 'http_header', 'find_string', 'replace_string') as $var) {

+                        // append array elements for this config variable from $newconfig to this config

+                        //$this->$var = $this->$var + $newconfig->$var;

+                        $this->$var = array_unique(array_merge($this->$var, $newconfig->$var));

+                }

+                // check for single statement commands

+                // we do not overwrite existing non null values

+                foreach (array('tidy', 'prune', 'parser', 'autodetect_on_failure') as $var) {

+                        if ($this->$var === null) $this->$var = $newconfig->$var;

+                }

+        }

+        

+        // returns SiteConfig instance if an appropriate one is found, false otherwise

+        // if $exact_host_match is true, we will not look for wildcard config matches

+        // by default if host is 'test.example.org' we will look for and load '.example.org.txt' if it exists

+        public static function build($host, $exact_host_match=false) {

+                $host = strtolower($host);

+                if (substr($host, 0, 4) == 'www.') $host = substr($host, 4);

+                if (!$host || (strlen($host) > 200) || !preg_match(self::HOSTNAME_REGEX, ltrim($host, '.'))) return false;

+                // check for site configuration

+                $try = array($host);

+                // should we look for wildcard matches 

+                if (!$exact_host_match) {

+                        $split = explode('.', $host);

+                        if (count($split) > 1) {

+                                array_shift($split);

+                                $try[] = '.'.implode('.', $split);

+                        }

+                }

+                

+                // look for site config file in primary folder

+                self::debug(". looking for site config for $host in primary folder");

+                foreach ($try as $h) {

+                        if (array_key_exists($h, self::$config_cache)) {

+                                self::debug("... site config for $h already loaded in this request");

+                                return self::$config_cache[$h];

+                        } elseif (self::$apc && ($sconfig = apc_fetch("sc.$h"))) {

+                                self::debug("... site config for $h in APC cache");

+                                return $sconfig;

+                        } elseif (file_exists(self::$config_path."/$h.txt")) {

+                                self::debug("... found site config ($h.txt)");

+                                $file_primary = self::$config_path."/$h.txt";

+                                $matched_name = $h;

+                                break;

+                        }

+                }

+                

+                // if we found site config, process it

+                if (isset($file_primary)) {

+                        $config_lines = file($file_primary, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

+                        if (!$config_lines || !is_array($config_lines)) return false;

+                        $config = self::build_from_array($config_lines);

+                        // if APC caching is available and enabled, mark this for cache

+                        //$config->cache_in_apc = true;

+                        $config->cache_key = $matched_name;

+                        

+                        // if autodetec on failure is off (on by default) we do not need to look

+                        // in secondary folder

+                        if (!$config->autodetect_on_failure()) {

+                                self::debug('... autodetect on failure is disabled (no other site config files will be loaded)');

+                                return $config;

+                        }

+                }

+                

+                // look for site config file in secondary folder

+                if (isset(self::$config_path_fallback)) {

+                        self::debug(". looking for site config for $host in secondary folder");

+                        foreach ($try as $h) {

+                                if (file_exists(self::$config_path_fallback."/$h.txt")) {

+                                        self::debug("... found site config in secondary folder ($h.txt)");

+                                        $file_secondary = self::$config_path_fallback."/$h.txt";

+                                        $matched_name = $h;

+                                        break;

+                                }

+                        }

+                        if (!isset($file_secondary)) {

+                                self::debug("... no site config match in secondary folder");

+                        }

+                }

+                

+                // return false if no config file found

+                if (!isset($file_primary) && !isset($file_secondary)) {

+                        self::debug("... no site config match for $host");

+                        return false;

+                }

+                

+                // return primary config if secondary not found

+                if (!isset($file_secondary) && isset($config)) {

+                        return $config;

+                }

+                

+                // process secondary config file

+                $config_lines = file($file_secondary, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

+                if (!$config_lines || !is_array($config_lines)) {

+                        // failed to process secondary

+                        if (isset($config)) {

+                                // return primary config

+                                return $config;

+                        } else {

+                                return false;

+                        }

+                }

+                

+                // merge with primary and return

+                if (isset($config)) {

+                        self::debug('. merging config files');

+                        $config->append(self::build_from_array($config_lines));

+                        return $config;

+                } else {

+                        // return just secondary

+                        $config = self::build_from_array($config_lines);

+                        // if APC caching is available and enabled, mark this for cache

+                        //$config->cache_in_apc = true;

+                        $config->cache_key = $matched_name;

+                        return $config;

+                }

+        }

+        

+        public static function build_from_array(array $lines) {

+                $config = new SiteConfig();

+                foreach ($lines as $line) {

+                        $line = trim($line);

+                        

+                        // skip comments, empty lines

+                        if ($line == '' || $line[0] == '#') continue;

+                        

+                        // get command

+                        $command = explode(':', $line, 2);

+                        // if there's no colon ':', skip this line

+                        if (count($command) != 2) continue;

+                        $val = trim($command[1]);

+                        $command = trim($command[0]);

+                        if ($command == '' || $val == '') continue;

+                        

+                        // check for commands where we accept multiple statements

+                        if (in_array($command, array('title', 'body', 'author', 'date', 'strip', 'strip_id_or_class', 'strip_image_src', 'single_page_link', 'single_page_link_in_feed', 'next_page_link', 'http_header', 'test_url', 'find_string', 'replace_string'))) {

+                                array_push($config->$command, $val);

+                        // check for single statement commands that evaluate to true or false

+                        } elseif (in_array($command, array('tidy', 'prune', 'autodetect_on_failure'))) {

+                                $config->$command = ($val == 'yes');

+                        // check for single statement commands stored as strings

+                        } elseif (in_array($command, array('parser'))) {

+                                $config->$command = $val;

+                        // check for replace_string(find): replace

+                        } elseif ((substr($command, -1) == ')') && preg_match('!^([a-z0-9_]+)\((.*?)\)$!i', $command, $match)) {

+                                if (in_array($match[1], array('replace_string'))) {

+                                        $command = $match[1];

+                                        array_push($config->find_string, $match[2]);

+                                        array_push($config->$command, $val);

+                                }

+                        }

+                }

+                return $config;

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/feedwriter/FeedItem.php b/inc/3rdparty/libraries/feedwriter/FeedItem.php
new file mode 100644
index 00000000..9373deeb
--- /dev/null
+++ b/inc/3rdparty/libraries/feedwriter/FeedItem.php
@@ -0,0 +1,185 @@
+<?php

+ /**

+ * Univarsel Feed Writer

+ * 

+ * FeedItem class - Used as feed element in FeedWriter class

+ *

+ * @package         UnivarselFeedWriter

+ * @author          Anis uddin Ahmad <anisniit@gmail.com>

+ * @link            http://www.ajaxray.com/projects/rss

+ */

+ class FeedItem

+ {

+        private $elements = array();    //Collection of feed elements

+        private $version;

+        

+        /**

+        * Constructor 

+        * 

+        * @param    contant     (RSS1/RSS2/ATOM) RSS2 is default. 

+        */ 

+        function __construct($version = RSS2)

+        {    

+                $this->version = $version;

+        }

+

+        /**

+        * Set element (overwrites existing elements with $elementName)

+        * 

+        * @access   public

+        * @param    srting  The tag name of an element

+        * @param    srting  The content of tag

+        * @param    array   Attributes(if any) in 'attrName' => 'attrValue' format

+        * @return   void

+        */

+        public function setElement($elementName, $content, $attributes = null)

+        {

+                if (isset($this->elements[$elementName])) {

+                        unset($this->elements[$elementName]);

+                }

+                $this->addElement($elementName, $content, $attributes);

+        }       

+        

+        /**

+        * Add an element to elements array

+        * 

+        * @access   public

+        * @param    srting  The tag name of an element

+        * @param    srting  The content of tag

+        * @param    array   Attributes(if any) in 'attrName' => 'attrValue' format

+        * @return   void

+        */

+        public function addElement($elementName, $content, $attributes = null)

+        {

+                $i = 0;

+                if (isset($this->elements[$elementName])) {

+                        $i = count($this->elements[$elementName]);

+                } else {

+                        $this->elements[$elementName] = array();

+                }

+                $this->elements[$elementName][$i]['name']       = $elementName;

+                $this->elements[$elementName][$i]['content']    = $content;

+                $this->elements[$elementName][$i]['attributes'] = $attributes;

+        }

+        

+        /**

+        * Set multiple feed elements from an array. 

+        * Elements which have attributes cannot be added by this method

+        * 

+        * @access   public

+        * @param    array   array of elements in 'tagName' => 'tagContent' format.

+        * @return   void

+        */

+        public function addElementArray($elementArray)

+        {

+                if(! is_array($elementArray)) return;

+                foreach ($elementArray as $elementName => $content) 

+                {

+                        $this->addElement($elementName, $content);

+                }

+        }

+        

+        /**

+        * Return the collection of elements in this feed item

+        * 

+        * @access   public

+        * @return   array

+        */

+        public function getElements()

+        {

+                return $this->elements;

+        }

+        

+        // Wrapper functions ------------------------------------------------------

+        

+        /**

+        * Set the 'dscription' element of feed item

+        * 

+        * @access   public

+        * @param    string  The content of 'description' element

+        * @return   void

+        */

+        public function setDescription($description) 

+        {

+                $tag = 'description'; 

+                $this->setElement($tag, $description);

+        }

+        

+        /**

+        * @desc     Set the 'title' element of feed item

+        * @access   public

+        * @param    string  The content of 'title' element

+        * @return   void

+        */

+        public function setTitle($title) 

+        {

+                $this->setElement('title', $title);     

+        }

+        

+        /**

+        * Set the 'date' element of feed item

+        * 

+        * @access   public

+        * @param    string  The content of 'date' element

+        * @return   void

+        */

+        public function setDate($date) 

+        {

+                if(! is_numeric($date))

+                {

+                        $date = strtotime($date);

+                }

+      

+                if($this->version == RSS2) 

+                {

+                        $tag    = 'pubDate';

+                        $value  = date(DATE_RSS, $date);

+                }

+                else                                

+                {

+                        $tag    = 'dc:date';

+                        $value  = date("Y-m-d", $date);

+                }

+                

+                $this->setElement($tag, $value);    

+        }

+        

+        /**

+        * Set the 'link' element of feed item

+        * 

+        * @access   public

+        * @param    string  The content of 'link' element

+        * @return   void

+        */

+        public function setLink($link) 

+        {

+                if($this->version == RSS2 || $this->version == RSS1)

+                {

+                        $this->setElement('link', $link);

+                }

+                else

+                {

+                        $this->setElement('link','',array('href'=>$link));

+                        $this->setElement('id', FeedWriter::uuid($link,'urn:uuid:'));

+                } 

+                

+        }

+        

+        /**

+        * Set the 'encloser' element of feed item

+        * For RSS 2.0 only

+        * 

+        * @access   public

+        * @param    string  The url attribute of encloser tag

+        * @param    string  The length attribute of encloser tag

+        * @param    string  The type attribute of encloser tag

+        * @return   void

+        */

+        public function setEncloser($url, $length, $type)

+        {

+                $attributes = array('url'=>$url, 'length'=>$length, 'type'=>$type);

+                $this->setElement('enclosure','',$attributes);

+        }

+        

+ } // end of class FeedItem

+?>

diff --git a/inc/3rdparty/libraries/feedwriter/FeedWriter.php b/inc/3rdparty/libraries/feedwriter/FeedWriter.php
new file mode 100644
index 00000000..adb2526c
--- /dev/null
+++ b/inc/3rdparty/libraries/feedwriter/FeedWriter.php
@@ -0,0 +1,441 @@
+<?php

+define('RSS2', 1, true);

+define('JSON', 2, true);

+define('JSONP', 3, true);

+

+ /**

+ * Univarsel Feed Writer class

+ *

+ * Genarate RSS2 or JSON (original: RSS 1.0, RSS2.0 and ATOM Feed)

+ *

+ * Modified for FiveFilters.org's Full-Text RSS project

+ * to allow for inclusion of hubs, JSON output. 

+ * Stripped RSS1 and ATOM support.

+ *                             

+ * @package     UnivarselFeedWriter

+ * @author      Anis uddin Ahmad <anisniit@gmail.com>

+ * @link        http://www.ajaxray.com/projects/rss

+ */

+ class FeedWriter

+ {

+         private $self          = null;     // self URL - http://feed2.w3.org/docs/warning/MissingAtomSelfLink.html

+         private $hubs          = array();  // PubSubHubbub hubs

+         private $channels      = array();  // Collection of channel elements

+         private $items         = array();  // Collection of items as object of FeedItem class.

+         private $data          = array();  // Store some other version wise data

+         private $CDATAEncoding = array();  // The tag names which have to encoded as CDATA

+         private $xsl                   = null;         // stylesheet to render RSS (used by Chrome)

+         private $json                  = null;         // JSON object

+         

+         private $version   = null; 

+        

+        /**

+        * Constructor

+        * 

+        * @param    constant    the version constant (RSS2 or JSON).       

+        */ 

+        function __construct($version = RSS2)

+        {       

+                $this->version = $version;

+                        

+                // Setting default value for assential channel elements

+                $this->channels['title']        = $version . ' Feed';

+                $this->channels['link']         = 'http://www.ajaxray.com/blog';

+                                

+                //Tag names to encode in CDATA

+                $this->CDATAEncoding = array('description', 'content:encoded', 'content', 'subtitle', 'summary');

+        }

+        

+        public function setFormat($format) {

+                $this->version = $format;

+        }

+

+        // Start # public functions ---------------------------------------------

+        

+        /**

+        * Set a channel element

+        * @access   public

+        * @param    srting  name of the channel tag

+        * @param    string  content of the channel tag

+        * @return   void

+        */

+        public function setChannelElement($elementName, $content)

+        {

+                $this->channels[$elementName] = $content ;

+        }

+        

+        /**

+        * Set multiple channel elements from an array. Array elements 

+        * should be 'channelName' => 'channelContent' format.

+        * 

+        * @access   public

+        * @param    array   array of channels

+        * @return   void

+        */

+        public function setChannelElementsFromArray($elementArray)

+        {

+                if(! is_array($elementArray)) return;

+                foreach ($elementArray as $elementName => $content) 

+                {

+                        $this->setChannelElement($elementName, $content);

+                }

+        }

+        

+        /**

+        * Genarate the actual RSS/JSON file

+        * 

+        * @access   public

+        * @return   void

+        */ 

+        public function genarateFeed()

+        {

+                if ($this->version == RSS2) {

+                        header('Content-type: text/xml; charset=UTF-8');

+                        // this line prevents Chrome 20 from prompting download

+                        // used by Google: https://news.google.com/news/feeds?ned=us&topic=b&output=rss

+                        header('X-content-type-options: nosniff');

+                } elseif ($this->version == JSON) {

+                        header('Content-type: application/json; charset=UTF-8');

+                        $this->json = new stdClass();

+                } elseif ($this->version == JSONP) {

+                        header('Content-type: application/javascript; charset=UTF-8');

+                        $this->json = new stdClass();

+                }

+                $this->printHead();

+                $this->printChannels();

+                $this->printItems();

+                $this->printTale();

+                if ($this->version == JSON || $this->version == JSONP) {

+                        echo json_encode($this->json);

+                }

+        }

+        

+        /**

+        * Create a new FeedItem.

+        * 

+        * @access   public

+        * @return   object  instance of FeedItem class

+        */

+        public function createNewItem()

+        {

+                $Item = new FeedItem($this->version);

+                return $Item;

+        }

+        

+        /**

+        * Add a FeedItem to the main class

+        * 

+        * @access   public

+        * @param    object  instance of FeedItem class

+        * @return   void

+        */

+        public function addItem($feedItem)

+        {

+                $this->items[] = $feedItem;    

+        }

+        

+        // Wrapper functions -------------------------------------------------------------------

+        

+        /**

+        * Set the 'title' channel element

+        * 

+        * @access   public

+        * @param    srting  value of 'title' channel tag

+        * @return   void

+        */

+        public function setTitle($title)

+        {

+                $this->setChannelElement('title', $title);

+        }

+        

+        /**

+        * Add a hub to the channel element

+        * 

+        * @access   public

+        * @param    string URL

+        * @return   void

+        */

+        public function addHub($hub)

+        {

+                $this->hubs[] = $hub;    

+        }

+        

+        /**

+        * Set XSL URL

+        * 

+        * @access   public

+        * @param    string URL

+        * @return   void

+        */

+        public function setXsl($xsl)

+        {

+                $this->xsl = $xsl;    

+        }       

+        

+        /**

+        * Set self URL

+        * 

+        * @access   public

+        * @param    string URL

+        * @return   void

+        */

+        public function setSelf($self)

+        {

+                $this->self = $self;    

+        }       

+        

+        /**

+        * Set the 'description' channel element

+        * 

+        * @access   public

+        * @param    srting  value of 'description' channel tag

+        * @return   void

+        */

+        public function setDescription($desciption)

+        {

+                $tag = ($this->version == ATOM)? 'subtitle' : 'description'; 

+                $this->setChannelElement($tag, $desciption);

+        }

+        

+        /**

+        * Set the 'link' channel element

+        * 

+        * @access   public

+        * @param    srting  value of 'link' channel tag

+        * @return   void

+        */

+        public function setLink($link)

+        {

+                $this->setChannelElement('link', $link);

+        }

+        

+        /**

+        * Set the 'image' channel element

+        * 

+        * @access   public

+        * @param    srting  title of image

+        * @param    srting  link url of the imahe

+        * @param    srting  path url of the image

+        * @return   void

+        */

+        public function setImage($title, $link, $url)

+        {

+                $this->setChannelElement('image', array('title'=>$title, 'link'=>$link, 'url'=>$url));

+        }

+        

+        // End # public functions ----------------------------------------------

+        

+        // Start # private functions ----------------------------------------------

+        

+        /**

+        * Prints the xml and rss namespace

+        * 

+        * @access   private

+        * @return   void

+        */

+        private function printHead()

+        {

+                if ($this->version == RSS2)

+                {

+                        $out  = '<?xml version="1.0" encoding="utf-8"?>'."\n";

+                        if ($this->xsl) $out .= '<?xml-stylesheet type="text/xsl" href="'.htmlspecialchars($this->xsl).'"?>' . PHP_EOL;

+                        $out .= '<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">' . PHP_EOL;

+                        echo $out;

+                }

+                elseif ($this->version == JSON || $this->version == JSONP)

+                {

+                        $this->json->rss = array('@attributes' => array('version' => '2.0'));

+                }

+        }

+        

+        /**

+        * Closes the open tags at the end of file

+        * 

+        * @access   private

+        * @return   void

+        */

+        private function printTale()

+        {

+                if ($this->version == RSS2)

+                {

+                        echo '</channel>',PHP_EOL,'</rss>'; 

+                }    

+                // do nothing for JSON

+        }

+

+        /**

+        * Creates a single node as xml format

+        * 

+        * @access   private

+        * @param    string  name of the tag

+        * @param    mixed   tag value as string or array of nested tags in 'tagName' => 'tagValue' format

+        * @param    array   Attributes(if any) in 'attrName' => 'attrValue' format

+        * @return   string  formatted xml tag

+        */

+        private function makeNode($tagName, $tagContent, $attributes = null)

+        {        

+                if ($this->version == RSS2)

+                {

+                        $nodeText = '';

+                        $attrText = '';

+                        if (is_array($attributes))

+                        {

+                                foreach ($attributes as $key => $value) 

+                                {

+                                        $attrText .= " $key=\"$value\" ";

+                                }

+                        }

+                        $nodeText .= "<{$tagName}{$attrText}>";

+                        if (is_array($tagContent))

+                        { 

+                                foreach ($tagContent as $key => $value) 

+                                {

+                                        $nodeText .= $this->makeNode($key, $value);

+                                }

+                        }

+                        else

+                        {

+                                //$nodeText .= (in_array($tagName, $this->CDATAEncoding))? $tagContent : htmlentities($tagContent);

+                                $nodeText .= htmlspecialchars($tagContent);

+                        }           

+                        //$nodeText .= (in_array($tagName, $this->CDATAEncoding))? "]]></$tagName>" : "</$tagName>";

+                        $nodeText .= "</$tagName>";

+                        return $nodeText . PHP_EOL;

+                }

+                elseif ($this->version == JSON || $this->version == JSONP)

+                {

+                        $tagName = (string)$tagName;

+                        $tagName = strtr($tagName, ':', '_');

+                        $node = null;

+                        if (!$tagContent && is_array($attributes) && count($attributes))

+                        {

+                                $node = array('@attributes' => $this->json_keys($attributes));

+                        } else {

+                                if (is_array($tagContent)) {

+                                        $node = $this->json_keys($tagContent);

+                                } else {

+                                        $node = $tagContent;

+                                }

+                        }

+                        return $node;

+                }

+                return ''; // should not get here

+        }

+        

+        private function json_keys(array $array) {

+                $new = array();

+                foreach ($array as $key => $val) {

+                        if (is_string($key)) $key = strtr($key, ':', '_');

+                        if (is_array($val)) {

+                                $new[$key] = $this->json_keys($val);

+                        } else {

+                                $new[$key] = $val;

+                        }

+                }

+                return $new;

+        }

+        

+        /**

+        * @desc     Print channels

+        * @access   private

+        * @return   void

+        */

+        private function printChannels()

+        {

+                //Start channel tag

+                if ($this->version == RSS2) {

+                        echo '<channel>' . PHP_EOL;    

+                        // add hubs

+                        foreach ($this->hubs as $hub) {

+                                //echo $this->makeNode('link', '', array('rel'=>'hub', 'href'=>$hub, 'xmlns'=>'http://www.w3.org/2005/Atom'));

+                                echo '<link rel="hub"  href="'.htmlspecialchars($hub).'" xmlns="http://www.w3.org/2005/Atom" />' . PHP_EOL;

+                        }

+                        // add self

+                        if (isset($this->self)) {

+                                //echo $this->makeNode('link', '', array('rel'=>'self', 'href'=>$this->self, 'xmlns'=>'http://www.w3.org/2005/Atom'));

+                                echo '<link rel="self" href="'.htmlspecialchars($this->self).'" xmlns="http://www.w3.org/2005/Atom" />' . PHP_EOL;

+                        }

+                        //Print Items of channel

+                        foreach ($this->channels as $key => $value) 

+                        {

+                                echo $this->makeNode($key, $value);

+                        }

+                } elseif ($this->version == JSON || $this->version == JSONP) {

+                        $this->json->rss['channel'] = (object)$this->json_keys($this->channels);

+                }

+        }

+        

+        /**

+        * Prints formatted feed items

+        * 

+        * @access   private

+        * @return   void

+        */

+        private function printItems()

+        {    

+                foreach ($this->items as $item) {

+                        $itemElements = $item->getElements();

+                        

+                        echo $this->startItem();

+                        

+                        if ($this->version == JSON || $this->version == JSONP) {

+                                $json_item = array();

+                        }

+                        

+                        foreach ($itemElements as $thisElement) {

+                                foreach ($thisElement as $instance) {                   

+                                        if ($this->version == RSS2) {

+                                                echo $this->makeNode($instance['name'], $instance['content'], $instance['attributes']);

+                                        } elseif ($this->version == JSON || $this->version == JSONP) {

+                                                $_json_node = $this->makeNode($instance['name'], $instance['content'], $instance['attributes']);

+                                                if (count($thisElement) > 1) {

+                                                        $json_item[strtr($instance['name'], ':', '_')][] = $_json_node;

+                                                } else {

+                                                        $json_item[strtr($instance['name'], ':', '_')] = $_json_node;

+                                                }

+                                        }

+                                }

+                        }

+                        echo $this->endItem();

+                        if ($this->version == JSON || $this->version == JSONP) {

+                                if (count($this->items) > 1) {

+                                        $this->json->rss['channel']->item[] = $json_item;

+                                } else {

+                                        $this->json->rss['channel']->item = $json_item;

+                                }

+                        }

+                }

+        }

+        

+        /**

+        * Make the starting tag of channels

+        * 

+        * @access   private

+        * @return   void

+        */

+        private function startItem()

+        {

+                if ($this->version == RSS2)

+                {

+                        echo '<item>' . PHP_EOL; 

+                }    

+                // nothing for JSON

+        }

+        

+        /**

+        * Closes feed item tag

+        * 

+        * @access   private

+        * @return   void

+        */

+        private function endItem()

+        {

+                if ($this->version == RSS2)

+                {

+                        echo '</item>' . PHP_EOL; 

+                }    

+                // nothing for JSON

+        }

+        

+        // End # private functions ----------------------------------------------

+ }
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/htmLawed/htmLawed.php b/inc/3rdparty/libraries/htmLawed/htmLawed.php
new file mode 100644
index 00000000..9a62aca5
--- /dev/null
+++ b/inc/3rdparty/libraries/htmLawed/htmLawed.php
@@ -0,0 +1,728 @@
+<?php
+
+/*
+htmLawed 1.1.14, 8 August 2012
+OOP code, 8 August 2012
+Copyright Santosh Patnaik
+Dual LGPL v3 and GPL v2+ license
+A PHP Labware internal utility; www.bioinformatics.org/phplabware/internal_utilities/htmLawed
+
+See htmLawed_README.txt/htm
+*/
+
+class htmLawed{
+// begin class
+public static function hl($t, $C=1, $S=array()){
+$C = is_array($C) ? $C : array();
+if(!empty($C['valid_xhtml'])){
+ $C['elements'] = empty($C['elements']) ? '*-center-dir-font-isindex-menu-s-strike-u' : $C['elements'];
+ $C['make_tag_strict'] = isset($C['make_tag_strict']) ? $C['make_tag_strict'] : 2;
+ $C['xml:lang'] = isset($C['xml:lang']) ? $C['xml:lang'] : 2;
+}
+// config eles
+$e = array('a'=>1, 'abbr'=>1, 'acronym'=>1, 'address'=>1, 'applet'=>1, 'area'=>1, 'b'=>1, 'bdo'=>1, 'big'=>1, 'blockquote'=>1, 'br'=>1, 'button'=>1, 'caption'=>1, 'center'=>1, 'cite'=>1, 'code'=>1, 'col'=>1, 'colgroup'=>1, 'dd'=>1, 'del'=>1, 'dfn'=>1, 'dir'=>1, 'div'=>1, 'dl'=>1, 'dt'=>1, 'em'=>1, 'embed'=>1, 'fieldset'=>1, 'font'=>1, 'form'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'hr'=>1, 'i'=>1, 'iframe'=>1, 'img'=>1, 'input'=>1, 'ins'=>1, 'isindex'=>1, 'kbd'=>1, 'label'=>1, 'legend'=>1, 'li'=>1, 'map'=>1, 'menu'=>1, 'noscript'=>1, 'object'=>1, 'ol'=>1, 'optgroup'=>1, 'option'=>1, 'p'=>1, 'param'=>1, 'pre'=>1, 'q'=>1, 'rb'=>1, 'rbc'=>1, 'rp'=>1, 'rt'=>1, 'rtc'=>1, 'ruby'=>1, 's'=>1, 'samp'=>1, 'script'=>1, 'select'=>1, 'small'=>1, 'span'=>1, 'strike'=>1, 'strong'=>1, 'sub'=>1, 'sup'=>1, 'table'=>1, 'tbody'=>1, 'td'=>1, 'textarea'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1, 'tt'=>1, 'u'=>1, 'ul'=>1, 'var'=>1); // 86/deprecated+embed+ruby
+if(!empty($C['safe'])){
+ unset($e['applet'], $e['embed'], $e['iframe'], $e['object'], $e['script']);
+}
+$x = !empty($C['elements']) ? str_replace(array("\n", "\r", "\t", ' '), '', $C['elements']) : '*';
+if($x == '-*'){$e = array();}
+elseif(strpos($x, '*') === false){$e = array_flip(explode(',', $x));}
+else{
+ if(isset($x[1])){
+  preg_match_all('`(?:^|-|\+)[^\-+]+?(?=-|\+|$)`', $x, $m, PREG_SET_ORDER);
+  for($i=count($m); --$i>=0;){$m[$i] = $m[$i][0];}
+  foreach($m as $v){
+   if($v[0] == '+'){$e[substr($v, 1)] = 1;}
+   if($v[0] == '-' && isset($e[($v = substr($v, 1))]) && !in_array('+'. $v, $m)){unset($e[$v]);}
+  }
+ }
+}
+$C['elements'] =& $e;
+// config attrs
+$x = !empty($C['deny_attribute']) ? str_replace(array("\n", "\r", "\t", ' '), '', $C['deny_attribute']) : '';
+$x = array_flip((isset($x[0]) && $x[0] == '*') ? explode('-', $x) : explode(',', $x. (!empty($C['safe']) ? ',on*' : '')));
+if(isset($x['on*'])){
+ unset($x['on*']);
+ $x += array('onblur'=>1, 'onchange'=>1, 'onclick'=>1, 'ondblclick'=>1, 'onfocus'=>1, 'onkeydown'=>1, 'onkeypress'=>1, 'onkeyup'=>1, 'onmousedown'=>1, 'onmousemove'=>1, 'onmouseout'=>1, 'onmouseover'=>1, 'onmouseup'=>1, 'onreset'=>1, 'onselect'=>1, 'onsubmit'=>1);
+}
+$C['deny_attribute'] = $x;
+// config URL
+$x = (isset($C['schemes'][2]) && strpos($C['schemes'], ':')) ? strtolower($C['schemes']) : 'href: aim, feed, file, ftp, gopher, http, https, irc, mailto, news, nntp, sftp, ssh, telnet; *:file, http, https';
+$C['schemes'] = array();
+foreach(explode(';', str_replace(array(' ', "\t", "\r", "\n"), '', $x)) as $v){
+ $x = $x2 = null; list($x, $x2) = explode(':', $v, 2);
+ if($x2){$C['schemes'][$x] = array_flip(explode(',', $x2));}
+}
+if(!isset($C['schemes']['*'])){$C['schemes']['*'] = array('file'=>1, 'http'=>1, 'https'=>1,);}
+if(!empty($C['safe']) && empty($C['schemes']['style'])){$C['schemes']['style'] = array('!'=>1);}
+$C['abs_url'] = isset($C['abs_url']) ? $C['abs_url'] : 0;
+if(!isset($C['base_url']) or !preg_match('`^[a-zA-Z\d.+\-]+://[^/]+/(.+?/)?$`', $C['base_url'])){
+ $C['base_url'] = $C['abs_url'] = 0;
+}
+// config rest
+$C['and_mark'] = empty($C['and_mark']) ? 0 : 1;
+$C['anti_link_spam'] = (isset($C['anti_link_spam']) && is_array($C['anti_link_spam']) && count($C['anti_link_spam']) == 2 && (empty($C['anti_link_spam'][0]) or htmLawed::hl_regex($C['anti_link_spam'][0])) && (empty($C['anti_link_spam'][1]) or htmLawed::hl_regex($C['anti_link_spam'][1]))) ? $C['anti_link_spam'] : 0;
+$C['anti_mail_spam'] = isset($C['anti_mail_spam']) ? $C['anti_mail_spam'] : 0;
+$C['balance'] = isset($C['balance']) ? (bool)$C['balance'] : 1;
+$C['cdata'] = isset($C['cdata']) ? $C['cdata'] : (empty($C['safe']) ? 3 : 0);
+$C['clean_ms_char'] = empty($C['clean_ms_char']) ? 0 : $C['clean_ms_char'];
+$C['comment'] = isset($C['comment']) ? $C['comment'] : (empty($C['safe']) ? 3 : 0);
+$C['css_expression'] = empty($C['css_expression']) ? 0 : 1;
+$C['direct_list_nest'] = empty($C['direct_list_nest']) ? 0 : 1;
+$C['hexdec_entity'] = isset($C['hexdec_entity']) ? $C['hexdec_entity'] : 1;
+$C['hook'] = (!empty($C['hook']) && function_exists($C['hook'])) ? $C['hook'] : 0;
+$C['hook_tag'] = (!empty($C['hook_tag']) && function_exists($C['hook_tag'])) ? $C['hook_tag'] : 0;
+$C['keep_bad'] = isset($C['keep_bad']) ? $C['keep_bad'] : 6;
+$C['lc_std_val'] = isset($C['lc_std_val']) ? (bool)$C['lc_std_val'] : 1;
+$C['make_tag_strict'] = isset($C['make_tag_strict']) ? $C['make_tag_strict'] : 1;
+$C['named_entity'] = isset($C['named_entity']) ? (bool)$C['named_entity'] : 1;
+$C['no_deprecated_attr'] = isset($C['no_deprecated_attr']) ? $C['no_deprecated_attr'] : 1;
+$C['parent'] = isset($C['parent'][0]) ? strtolower($C['parent']) : 'body';
+$C['show_setting'] = !empty($C['show_setting']) ? $C['show_setting'] : 0;
+$C['style_pass'] = empty($C['style_pass']) ? 0 : 1;
+$C['tidy'] = empty($C['tidy']) ? 0 : $C['tidy'];
+$C['unique_ids'] = isset($C['unique_ids']) ? $C['unique_ids'] : 1;
+$C['xml:lang'] = isset($C['xml:lang']) ? $C['xml:lang'] : 0;
+
+if(isset($GLOBALS['C'])){$reC = $GLOBALS['C'];}
+$GLOBALS['C'] = $C;
+$S = is_array($S) ? $S : htmLawed::hl_spec($S);
+if(isset($GLOBALS['S'])){$reS = $GLOBALS['S'];}
+$GLOBALS['S'] = $S;
+
+$t = preg_replace('`[\x00-\x08\x0b-\x0c\x0e-\x1f]`', '', $t);
+if($C['clean_ms_char']){
+ $x = array("\x7f"=>'', "\x80"=>'&#8364;', "\x81"=>'', "\x83"=>'&#402;', "\x85"=>'&#8230;', "\x86"=>'&#8224;', "\x87"=>'&#8225;', "\x88"=>'&#710;', "\x89"=>'&#8240;', "\x8a"=>'&#352;', "\x8b"=>'&#8249;', "\x8c"=>'&#338;', "\x8d"=>'', "\x8e"=>'&#381;', "\x8f"=>'', "\x90"=>'', "\x95"=>'&#8226;', "\x96"=>'&#8211;', "\x97"=>'&#8212;', "\x98"=>'&#732;', "\x99"=>'&#8482;', "\x9a"=>'&#353;', "\x9b"=>'&#8250;', "\x9c"=>'&#339;', "\x9d"=>'', "\x9e"=>'&#382;', "\x9f"=>'&#376;');
+ $x = $x + ($C['clean_ms_char'] == 1 ? array("\x82"=>'&#8218;', "\x84"=>'&#8222;', "\x91"=>'&#8216;', "\x92"=>'&#8217;', "\x93"=>'&#8220;', "\x94"=>'&#8221;') : array("\x82"=>'\'', "\x84"=>'"', "\x91"=>'\'', "\x92"=>'\'', "\x93"=>'"', "\x94"=>'"'));
+ $t = strtr($t, $x);
+}
+if($C['cdata'] or $C['comment']){$t = preg_replace_callback('`<!(?:(?:--.*?--)|(?:\[CDATA\[.*?\]\]))>`sm', 'htmLawed::hl_cmtcd', $t);}
+$t = preg_replace_callback('`&amp;([A-Za-z][A-Za-z0-9]{1,30}|#(?:[0-9]{1,8}|[Xx][0-9A-Fa-f]{1,7}));`', 'htmLawed::hl_ent', str_replace('&', '&amp;', $t));
+if($C['unique_ids'] && !isset($GLOBALS['hl_Ids'])){$GLOBALS['hl_Ids'] = array();}
+if($C['hook']){$t = $C['hook']($t, $C, $S);}
+if($C['show_setting'] && preg_match('`^[a-z][a-z0-9_]*$`i', $C['show_setting'])){
+ $GLOBALS[$C['show_setting']] = array('config'=>$C, 'spec'=>$S, 'time'=>microtime());
+}
+// main
+$t = preg_replace_callback('`<(?:(?:\s|$)|(?:[^>]*(?:>|$)))|>`m', 'htmLawed::hl_tag', $t);
+$t = $C['balance'] ? htmLawed::hl_bal($t, $C['keep_bad'], $C['parent']) : $t;
+$t = (($C['cdata'] or $C['comment']) && strpos($t, "\x01") !== false) ? str_replace(array("\x01", "\x02", "\x03", "\x04", "\x05"), array('', '', '&', '<', '>'), $t) : $t;
+$t = $C['tidy'] ? htmLawed::hl_tidy($t, $C['tidy'], $C['parent']) : $t;
+unset($C, $e);
+if(isset($reC)){$GLOBALS['C'] = $reC;}
+if(isset($reS)){$GLOBALS['S'] = $reS;}
+return $t;
+// eof
+}
+
+public static function hl_attrval($t, $p){
+// check attr val against $S
+$o = 1; $l = strlen($t);
+foreach($p as $k=>$v){
+ switch($k){
+  case 'maxlen':if($l > $v){$o = 0;}
+  break; case 'minlen': if($l < $v){$o = 0;}
+  break; case 'maxval': if((float)($t) > $v){$o = 0;}
+  break; case 'minval': if((float)($t) < $v){$o = 0;}
+  break; case 'match': if(!preg_match($v, $t)){$o = 0;}
+  break; case 'nomatch': if(preg_match($v, $t)){$o = 0;}
+  break; case 'oneof':
+   $m = 0;
+   foreach(explode('|', $v) as $n){if($t == $n){$m = 1; break;}}
+   $o = $m;
+  break; case 'noneof':
+   $m = 1;
+   foreach(explode('|', $v) as $n){if($t == $n){$m = 0; break;}}
+   $o = $m;
+  break; default:
+  break;
+ }
+ if(!$o){break;}
+}
+return ($o ? $t : (isset($p['default']) ? $p['default'] : 0));
+// eof
+}
+
+public static function hl_bal($t, $do=1, $in='div'){
+// balance tags
+// by content
+$cB = array('blockquote'=>1, 'form'=>1, 'map'=>1, 'noscript'=>1); // Block
+$cE = array('area'=>1, 'br'=>1, 'col'=>1, 'embed'=>1, 'hr'=>1, 'img'=>1, 'input'=>1, 'isindex'=>1, 'param'=>1); // Empty
+$cF = array('button'=>1, 'del'=>1, 'div'=>1, 'dd'=>1, 'fieldset'=>1, 'iframe'=>1, 'ins'=>1, 'li'=>1, 'noscript'=>1, 'object'=>1, 'td'=>1, 'th'=>1); // Flow; later context-wise dynamic move of ins & del to $cI
+$cI = array('a'=>1, 'abbr'=>1, 'acronym'=>1, 'address'=>1, 'b'=>1, 'bdo'=>1, 'big'=>1, 'caption'=>1, 'cite'=>1, 'code'=>1, 'dfn'=>1, 'dt'=>1, 'em'=>1, 'font'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'i'=>1, 'kbd'=>1, 'label'=>1, 'legend'=>1, 'p'=>1, 'pre'=>1, 'q'=>1, 'rb'=>1, 'rt'=>1, 's'=>1, 'samp'=>1, 'small'=>1, 'span'=>1, 'strike'=>1, 'strong'=>1, 'sub'=>1, 'sup'=>1, 'tt'=>1, 'u'=>1, 'var'=>1); // Inline
+$cN = array('a'=>array('a'=>1), 'button'=>array('a'=>1, 'button'=>1, 'fieldset'=>1, 'form'=>1, 'iframe'=>1, 'input'=>1, 'label'=>1, 'select'=>1, 'textarea'=>1), 'fieldset'=>array('fieldset'=>1), 'form'=>array('form'=>1), 'label'=>array('label'=>1), 'noscript'=>array('script'=>1), 'pre'=>array('big'=>1, 'font'=>1, 'img'=>1, 'object'=>1, 'script'=>1, 'small'=>1, 'sub'=>1, 'sup'=>1), 'rb'=>array('ruby'=>1), 'rt'=>array('ruby'=>1)); // Illegal
+$cN2 = array_keys($cN);
+$cR = array('blockquote'=>1, 'dir'=>1, 'dl'=>1, 'form'=>1, 'map'=>1, 'menu'=>1, 'noscript'=>1, 'ol'=>1, 'optgroup'=>1, 'rbc'=>1, 'rtc'=>1, 'ruby'=>1, 'select'=>1, 'table'=>1, 'tbody'=>1, 'tfoot'=>1, 'thead'=>1, 'tr'=>1, 'ul'=>1);
+$cS = array('colgroup'=>array('col'=>1), 'dir'=>array('li'=>1), 'dl'=>array('dd'=>1, 'dt'=>1), 'menu'=>array('li'=>1), 'ol'=>array('li'=>1), 'optgroup'=>array('option'=>1), 'option'=>array('#pcdata'=>1), 'rbc'=>array('rb'=>1), 'rp'=>array('#pcdata'=>1), 'rtc'=>array('rt'=>1), 'ruby'=>array('rb'=>1, 'rbc'=>1, 'rp'=>1, 'rt'=>1, 'rtc'=>1), 'select'=>array('optgroup'=>1, 'option'=>1), 'script'=>array('#pcdata'=>1), 'table'=>array('caption'=>1, 'col'=>1, 'colgroup'=>1, 'tfoot'=>1, 'tbody'=>1, 'tr'=>1, 'thead'=>1), 'tbody'=>array('tr'=>1), 'tfoot'=>array('tr'=>1), 'textarea'=>array('#pcdata'=>1), 'thead'=>array('tr'=>1), 'tr'=>array('td'=>1, 'th'=>1), 'ul'=>array('li'=>1)); // Specific - immediate parent-child
+if($GLOBALS['C']['direct_list_nest']){$cS['ol'] = $cS['ul'] += array('ol'=>1, 'ul'=>1);}
+$cO = array('address'=>array('p'=>1), 'applet'=>array('param'=>1), 'blockquote'=>array('script'=>1), 'fieldset'=>array('legend'=>1, '#pcdata'=>1), 'form'=>array('script'=>1), 'map'=>array('area'=>1), 'object'=>array('param'=>1, 'embed'=>1)); // Other
+$cT = array('colgroup'=>1, 'dd'=>1, 'dt'=>1, 'li'=>1, 'option'=>1, 'p'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1); // Omitable closing
+// block/inline type; ins & del both type; #pcdata: text
+$eB = array('address'=>1, 'blockquote'=>1, 'center'=>1, 'del'=>1, 'dir'=>1, 'dl'=>1, 'div'=>1, 'fieldset'=>1, 'form'=>1, 'ins'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'hr'=>1, 'isindex'=>1, 'menu'=>1, 'noscript'=>1, 'ol'=>1, 'p'=>1, 'pre'=>1, 'table'=>1, 'ul'=>1);
+$eI = array('#pcdata'=>1, 'a'=>1, 'abbr'=>1, 'acronym'=>1, 'applet'=>1, 'b'=>1, 'bdo'=>1, 'big'=>1, 'br'=>1, 'button'=>1, 'cite'=>1, 'code'=>1, 'del'=>1, 'dfn'=>1, 'em'=>1, 'embed'=>1, 'font'=>1, 'i'=>1, 'iframe'=>1, 'img'=>1, 'input'=>1, 'ins'=>1, 'kbd'=>1, 'label'=>1, 'map'=>1, 'object'=>1, 'q'=>1, 'ruby'=>1, 's'=>1, 'samp'=>1, 'select'=>1, 'script'=>1, 'small'=>1, 'span'=>1, 'strike'=>1, 'strong'=>1, 'sub'=>1, 'sup'=>1, 'textarea'=>1, 'tt'=>1, 'u'=>1, 'var'=>1);
+$eN = array('a'=>1, 'big'=>1, 'button'=>1, 'fieldset'=>1, 'font'=>1, 'form'=>1, 'iframe'=>1, 'img'=>1, 'input'=>1, 'label'=>1, 'object'=>1, 'ruby'=>1, 'script'=>1, 'select'=>1, 'small'=>1, 'sub'=>1, 'sup'=>1, 'textarea'=>1); // Exclude from specific ele; $cN values
+$eO = array('area'=>1, 'caption'=>1, 'col'=>1, 'colgroup'=>1, 'dd'=>1, 'dt'=>1, 'legend'=>1, 'li'=>1, 'optgroup'=>1, 'option'=>1, 'param'=>1, 'rb'=>1, 'rbc'=>1, 'rp'=>1, 'rt'=>1, 'rtc'=>1, 'script'=>1, 'tbody'=>1, 'td'=>1, 'tfoot'=>1, 'thead'=>1, 'th'=>1, 'tr'=>1); // Missing in $eB & $eI
+$eF = $eB + $eI;
+
+// $in sets allowed child
+$in = ((isset($eF[$in]) && $in != '#pcdata') or isset($eO[$in])) ? $in : 'div';
+if(isset($cE[$in])){
+ return (!$do ? '' : str_replace(array('<', '>'), array('&lt;', '&gt;'), $t));
+}
+if(isset($cS[$in])){$inOk = $cS[$in];}
+elseif(isset($cI[$in])){$inOk = $eI; $cI['del'] = 1; $cI['ins'] = 1;}
+elseif(isset($cF[$in])){$inOk = $eF; unset($cI['del'], $cI['ins']);}
+elseif(isset($cB[$in])){$inOk = $eB; unset($cI['del'], $cI['ins']);}
+if(isset($cO[$in])){$inOk = $inOk + $cO[$in];}
+if(isset($cN[$in])){$inOk = array_diff_assoc($inOk, $cN[$in]);}
+
+$t = explode('<', $t);
+$ok = $q = array(); // $q seq list of open non-empty ele
+ob_start();
+
+for($i=-1, $ci=count($t); ++$i<$ci;){
+ // allowed $ok in parent $p
+ if($ql = count($q)){
+  $p = array_pop($q);
+  $q[] = $p;
+  if(isset($cS[$p])){$ok = $cS[$p];}
+  elseif(isset($cI[$p])){$ok = $eI; $cI['del'] = 1; $cI['ins'] = 1;}
+  elseif(isset($cF[$p])){$ok = $eF; unset($cI['del'], $cI['ins']);}
+  elseif(isset($cB[$p])){$ok = $eB; unset($cI['del'], $cI['ins']);}
+  if(isset($cO[$p])){$ok = $ok + $cO[$p];}
+  if(isset($cN[$p])){$ok = array_diff_assoc($ok, $cN[$p]);}
+ }else{$ok = $inOk; unset($cI['del'], $cI['ins']);}
+ // bad tags, & ele content
+ if(isset($e) && ($do == 1 or (isset($ok['#pcdata']) && ($do == 3 or $do == 5)))){
+  echo '&lt;', $s, $e, $a, '&gt;';
+ }
+ if(isset($x[0])){
+  if(strlen(trim($x)) && (($ql && isset($cB[$p])) or (isset($cB[$in]) && !$ql))){
+   echo '<div>', $x, '</div>';
+  }
+  elseif($do < 3 or isset($ok['#pcdata'])){echo $x;}
+  elseif(strpos($x, "\x02\x04")){
+   foreach(preg_split('`(\x01\x02[^\x01\x02]+\x02\x01)`', $x, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY) as $v){
+    echo (substr($v, 0, 2) == "\x01\x02" ? $v : ($do > 4 ? preg_replace('`\S`', '', $v) : ''));
+   }
+  }elseif($do > 4){echo preg_replace('`\S`', '', $x);}
+ }
+ // get markup
+ if(!preg_match('`^(/?)([a-z1-6]+)([^>]*)>(.*)`sm', $t[$i], $r)){$x = $t[$i]; continue;}
+ $s = null; $e = null; $a = null; $x = null; list($all, $s, $e, $a, $x) = $r;
+ // close tag
+ if($s){
+  if(isset($cE[$e]) or !in_array($e, $q)){continue;} // Empty/unopen
+  if($p == $e){array_pop($q); echo '</', $e, '>'; unset($e); continue;} // Last open
+  $add = ''; // Nesting - close open tags that need to be
+  for($j=-1, $cj=count($q); ++$j<$cj;){
+   if(($d = array_pop($q)) == $e){break;}
+   else{$add .= "</{$d}>";}
+  }
+  echo $add, '</', $e, '>'; unset($e); continue;
+ }
+ // open tag
+ // $cB ele needs $eB ele as child
+ if(isset($cB[$e]) && strlen(trim($x))){
+  $t[$i] = "{$e}{$a}>";
+  array_splice($t, $i+1, 0, 'div>'. $x); unset($e, $x); ++$ci; --$i; continue;
+ }
+ if((($ql && isset($cB[$p])) or (isset($cB[$in]) && !$ql)) && !isset($eB[$e]) && !isset($ok[$e])){
+  array_splice($t, $i, 0, 'div>'); unset($e, $x); ++$ci; --$i; continue;
+ }
+ // if no open ele, $in = parent; mostly immediate parent-child relation should hold
+ if(!$ql or !isset($eN[$e]) or !array_intersect($q, $cN2)){
+  if(!isset($ok[$e])){
+   if($ql && isset($cT[$p])){echo '</', array_pop($q), '>'; unset($e, $x); --$i;}
+   continue;
+  }
+  if(!isset($cE[$e])){$q[] = $e;}
+  echo '<', $e, $a, '>'; unset($e); continue;
+ }
+ // specific parent-child
+ if(isset($cS[$p][$e])){
+  if(!isset($cE[$e])){$q[] = $e;}
+  echo '<', $e, $a, '>'; unset($e); continue;
+ }
+ // nesting
+ $add = '';
+ $q2 = array();
+ for($k=-1, $kc=count($q); ++$k<$kc;){
+  $d = $q[$k];
+  $ok2 = array();
+  if(isset($cS[$d])){$q2[] = $d; continue;}
+  $ok2 = isset($cI[$d]) ? $eI : $eF;
+  if(isset($cO[$d])){$ok2 = $ok2 + $cO[$d];}
+  if(isset($cN[$d])){$ok2 = array_diff_assoc($ok2, $cN[$d]);}
+  if(!isset($ok2[$e])){
+   if(!$k && !isset($inOk[$e])){continue 2;}
+   $add = "</{$d}>";
+   for(;++$k<$kc;){$add = "</{$q[$k]}>{$add}";}
+   break;
+  }
+  else{$q2[] = $d;}
+ }
+ $q = $q2;
+ if(!isset($cE[$e])){$q[] = $e;}
+ echo $add, '<', $e, $a, '>'; unset($e); continue;
+}
+
+// end
+if($ql = count($q)){
+ $p = array_pop($q);
+ $q[] = $p;
+ if(isset($cS[$p])){$ok = $cS[$p];}
+ elseif(isset($cI[$p])){$ok = $eI; $cI['del'] = 1; $cI['ins'] = 1;}
+ elseif(isset($cF[$p])){$ok = $eF; unset($cI['del'], $cI['ins']);}
+ elseif(isset($cB[$p])){$ok = $eB; unset($cI['del'], $cI['ins']);}
+ if(isset($cO[$p])){$ok = $ok + $cO[$p];}
+ if(isset($cN[$p])){$ok = array_diff_assoc($ok, $cN[$p]);}
+}else{$ok = $inOk; unset($cI['del'], $cI['ins']);}
+if(isset($e) && ($do == 1 or (isset($ok['#pcdata']) && ($do == 3 or $do == 5)))){
+ echo '&lt;', $s, $e, $a, '&gt;';
+}
+if(isset($x[0])){
+ if(strlen(trim($x)) && (($ql && isset($cB[$p])) or (isset($cB[$in]) && !$ql))){
+  echo '<div>', $x, '</div>';
+ }
+ elseif($do < 3 or isset($ok['#pcdata'])){echo $x;}
+ elseif(strpos($x, "\x02\x04")){
+  foreach(preg_split('`(\x01\x02[^\x01\x02]+\x02\x01)`', $x, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY) as $v){
+   echo (substr($v, 0, 2) == "\x01\x02" ? $v : ($do > 4 ? preg_replace('`\S`', '', $v) : ''));
+  }
+ }elseif($do > 4){echo preg_replace('`\S`', '', $x);}
+}
+while(!empty($q) && ($e = array_pop($q))){echo '</', $e, '>';}
+$o = ob_get_contents();
+ob_end_clean();
+return $o;
+// eof
+}
+
+public static function hl_cmtcd($t){
+// comment/CDATA sec handler
+$t = $t[0];
+global $C;
+if(!($v = $C[$n = $t[3] == '-' ? 'comment' : 'cdata'])){return $t;}
+if($v == 1){return '';}
+if($n == 'comment'){
+ if(substr(($t = preg_replace('`--+`', '-', substr($t, 4, -3))), -1) != ' '){$t .= ' ';}
+}
+else{$t = substr($t, 1, -1);}
+$t = $v == 2 ? str_replace(array('&', '<', '>'), array('&amp;', '&lt;', '&gt;'), $t) : $t;
+return str_replace(array('&', '<', '>'), array("\x03", "\x04", "\x05"), ($n == 'comment' ? "\x01\x02\x04!--$t--\x05\x02\x01" : "\x01\x01\x04$t\x05\x01\x01"));
+// eof
+}
+
+public static function hl_ent($t){
+// entitity handler
+global $C;
+$t = $t[1];
+static $U = array('quot'=>1,'amp'=>1,'lt'=>1,'gt'=>1);
+static $N = array('fnof'=>'402', 'Alpha'=>'913', 'Beta'=>'914', 'Gamma'=>'915', 'Delta'=>'916', 'Epsilon'=>'917', 'Zeta'=>'918', 'Eta'=>'919', 'Theta'=>'920', 'Iota'=>'921', 'Kappa'=>'922', 'Lambda'=>'923', 'Mu'=>'924', 'Nu'=>'925', 'Xi'=>'926', 'Omicron'=>'927', 'Pi'=>'928', 'Rho'=>'929', 'Sigma'=>'931', 'Tau'=>'932', 'Upsilon'=>'933', 'Phi'=>'934', 'Chi'=>'935', 'Psi'=>'936', 'Omega'=>'937', 'alpha'=>'945', 'beta'=>'946', 'gamma'=>'947', 'delta'=>'948', 'epsilon'=>'949', 'zeta'=>'950', 'eta'=>'951', 'theta'=>'952', 'iota'=>'953', 'kappa'=>'954', 'lambda'=>'955', 'mu'=>'956', 'nu'=>'957', 'xi'=>'958', 'omicron'=>'959', 'pi'=>'960', 'rho'=>'961', 'sigmaf'=>'962', 'sigma'=>'963', 'tau'=>'964', 'upsilon'=>'965', 'phi'=>'966', 'chi'=>'967', 'psi'=>'968', 'omega'=>'969', 'thetasym'=>'977', 'upsih'=>'978', 'piv'=>'982', 'bull'=>'8226', 'hellip'=>'8230', 'prime'=>'8242', 'Prime'=>'8243', 'oline'=>'8254', 'frasl'=>'8260', 'weierp'=>'8472', 'image'=>'8465', 'real'=>'8476', 'trade'=>'8482', 'alefsym'=>'8501', 'larr'=>'8592', 'uarr'=>'8593', 'rarr'=>'8594', 'darr'=>'8595', 'harr'=>'8596', 'crarr'=>'8629', 'lArr'=>'8656', 'uArr'=>'8657', 'rArr'=>'8658', 'dArr'=>'8659', 'hArr'=>'8660', 'forall'=>'8704', 'part'=>'8706', 'exist'=>'8707', 'empty'=>'8709', 'nabla'=>'8711', 'isin'=>'8712', 'notin'=>'8713', 'ni'=>'8715', 'prod'=>'8719', 'sum'=>'8721', 'minus'=>'8722', 'lowast'=>'8727', 'radic'=>'8730', 'prop'=>'8733', 'infin'=>'8734', 'ang'=>'8736', 'and'=>'8743', 'or'=>'8744', 'cap'=>'8745', 'cup'=>'8746', 'int'=>'8747', 'there4'=>'8756', 'sim'=>'8764', 'cong'=>'8773', 'asymp'=>'8776', 'ne'=>'8800', 'equiv'=>'8801', 'le'=>'8804', 'ge'=>'8805', 'sub'=>'8834', 'sup'=>'8835', 'nsub'=>'8836', 'sube'=>'8838', 'supe'=>'8839', 'oplus'=>'8853', 'otimes'=>'8855', 'perp'=>'8869', 'sdot'=>'8901', 'lceil'=>'8968', 'rceil'=>'8969', 'lfloor'=>'8970', 'rfloor'=>'8971', 'lang'=>'9001', 'rang'=>'9002', 'loz'=>'9674', 'spades'=>'9824', 'clubs'=>'9827', 'hearts'=>'9829', 'diams'=>'9830', 'apos'=>'39',  'OElig'=>'338', 'oelig'=>'339', 'Scaron'=>'352', 'scaron'=>'353', 'Yuml'=>'376', 'circ'=>'710', 'tilde'=>'732', 'ensp'=>'8194', 'emsp'=>'8195', 'thinsp'=>'8201', 'zwnj'=>'8204', 'zwj'=>'8205', 'lrm'=>'8206', 'rlm'=>'8207', 'ndash'=>'8211', 'mdash'=>'8212', 'lsquo'=>'8216', 'rsquo'=>'8217', 'sbquo'=>'8218', 'ldquo'=>'8220', 'rdquo'=>'8221', 'bdquo'=>'8222', 'dagger'=>'8224', 'Dagger'=>'8225', 'permil'=>'8240', 'lsaquo'=>'8249', 'rsaquo'=>'8250', 'euro'=>'8364', 'nbsp'=>'160', 'iexcl'=>'161', 'cent'=>'162', 'pound'=>'163', 'curren'=>'164', 'yen'=>'165', 'brvbar'=>'166', 'sect'=>'167', 'uml'=>'168', 'copy'=>'169', 'ordf'=>'170', 'laquo'=>'171', 'not'=>'172', 'shy'=>'173', 'reg'=>'174', 'macr'=>'175', 'deg'=>'176', 'plusmn'=>'177', 'sup2'=>'178', 'sup3'=>'179', 'acute'=>'180', 'micro'=>'181', 'para'=>'182', 'middot'=>'183', 'cedil'=>'184', 'sup1'=>'185', 'ordm'=>'186', 'raquo'=>'187', 'frac14'=>'188', 'frac12'=>'189', 'frac34'=>'190', 'iquest'=>'191', 'Agrave'=>'192', 'Aacute'=>'193', 'Acirc'=>'194', 'Atilde'=>'195', 'Auml'=>'196', 'Aring'=>'197', 'AElig'=>'198', 'Ccedil'=>'199', 'Egrave'=>'200', 'Eacute'=>'201', 'Ecirc'=>'202', 'Euml'=>'203', 'Igrave'=>'204', 'Iacute'=>'205', 'Icirc'=>'206', 'Iuml'=>'207', 'ETH'=>'208', 'Ntilde'=>'209', 'Ograve'=>'210', 'Oacute'=>'211', 'Ocirc'=>'212', 'Otilde'=>'213', 'Ouml'=>'214', 'times'=>'215', 'Oslash'=>'216', 'Ugrave'=>'217', 'Uacute'=>'218', 'Ucirc'=>'219', 'Uuml'=>'220', 'Yacute'=>'221', 'THORN'=>'222', 'szlig'=>'223', 'agrave'=>'224', 'aacute'=>'225', 'acirc'=>'226', 'atilde'=>'227', 'auml'=>'228', 'aring'=>'229', 'aelig'=>'230', 'ccedil'=>'231', 'egrave'=>'232', 'eacute'=>'233', 'ecirc'=>'234', 'euml'=>'235', 'igrave'=>'236', 'iacute'=>'237', 'icirc'=>'238', 'iuml'=>'239', 'eth'=>'240', 'ntilde'=>'241', 'ograve'=>'242', 'oacute'=>'243', 'ocirc'=>'244', 'otilde'=>'245', 'ouml'=>'246', 'divide'=>'247', 'oslash'=>'248', 'ugrave'=>'249', 'uacute'=>'250', 'ucirc'=>'251', 'uuml'=>'252', 'yacute'=>'253', 'thorn'=>'254', 'yuml'=>'255');
+if($t[0] != '#'){
+ return ($C['and_mark'] ? "\x06" : '&'). (isset($U[$t]) ? $t : (isset($N[$t]) ? (!$C['named_entity'] ? '#'. ($C['hexdec_entity'] > 1 ? 'x'. dechex($N[$t]) : $N[$t]) : $t) : 'amp;'. $t)). ';';
+}
+if(($n = ctype_digit($t = substr($t, 1)) ? intval($t) : hexdec(substr($t, 1))) < 9 or ($n > 13 && $n < 32) or $n == 11 or $n == 12 or ($n > 126 && $n < 160 && $n != 133) or ($n > 55295 && ($n < 57344 or ($n > 64975 && $n < 64992) or $n == 65534 or $n == 65535 or $n > 1114111))){
+ return ($C['and_mark'] ? "\x06" : '&'). "amp;#{$t};";
+}
+return ($C['and_mark'] ? "\x06" : '&'). '#'. (((ctype_digit($t) && $C['hexdec_entity'] < 2) or !$C['hexdec_entity']) ? $n : 'x'. dechex($n)). ';';
+// eof
+}
+
+public static function hl_prot($p, $c=null){
+// check URL scheme
+global $C;
+$b = $a = '';
+if($c == null){$c = 'style'; $b = $p[1]; $a = $p[3]; $p = trim($p[2]);}
+$c = isset($C['schemes'][$c]) ? $C['schemes'][$c] : $C['schemes']['*'];
+static $d = 'denied:';
+if(isset($c['!']) && substr($p, 0, 7) != $d){$p = "$d$p";}
+if(isset($c['*']) or !strcspn($p, '#?;') or (substr($p, 0, 7) == $d)){return "{$b}{$p}{$a}";} // All ok, frag, query, param
+if(preg_match('`^([a-z\d\-+.&#; ]+?)(:|&#(58|x3a);|%3a|\\\\0{0,4}3a).`i', $p, $m) && !isset($c[strtolower($m[1])])){ // Denied prot
+ return "{$b}{$d}{$p}{$a}";
+}
+if($C['abs_url']){
+ if($C['abs_url'] == -1 && strpos($p, $C['base_url']) === 0){ // Make url rel
+  $p = substr($p, strlen($C['base_url']));
+ }elseif(empty($m[1])){ // Make URL abs
+  if(substr($p, 0, 2) == '//'){$p = substr($C['base_url'], 0, strpos($C['base_url'], ':')+1). $p;}
+  elseif($p[0] == '/'){$p = preg_replace('`(^.+?://[^/]+)(.*)`', '$1', $C['base_url']). $p;}
+  elseif(strcspn($p, './')){$p = $C['base_url']. $p;}
+  else{
+   preg_match('`^([a-zA-Z\d\-+.]+://[^/]+)(.*)`', $C['base_url'], $m);
+   $p = preg_replace('`(?<=/)\./`', '', $m[2]. $p);
+   while(preg_match('`(?<=/)([^/]{3,}|[^/.]+?|\.[^/.]|[^/.]\.)/\.\./`', $p)){
+    $p = preg_replace('`(?<=/)([^/]{3,}|[^/.]+?|\.[^/.]|[^/.]\.)/\.\./`', '', $p);
+   }
+   $p = $m[1]. $p;
+  }
+ }
+}
+return "{$b}{$p}{$a}";
+// eof
+}
+
+public static function hl_regex($p){
+// ?regex
+if(empty($p)){return 0;}
+if($t = ini_get('track_errors')){$o = isset($php_errormsg) ? $php_errormsg : null;}
+else{ini_set('track_errors', 1);}
+unset($php_errormsg);
+if(($d = ini_get('display_errors'))){ini_set('display_errors', 0);}
+preg_match($p, '');
+if($d){ini_set('display_errors', 1);}
+$r = isset($php_errormsg) ? 0 : 1;
+if($t){$php_errormsg = isset($o) ? $o : null;}
+else{ini_set('track_errors', 0);}
+return $r;
+// eof
+}
+
+public static function hl_spec($t){
+// final $spec
+$s = array();
+$t = str_replace(array("\t", "\r", "\n", ' '), '', preg_replace('/"(?>(`.|[^"])*)"/sme', 'substr(str_replace(array(";", "|", "~", " ", ",", "/", "(", ")", \'`"\'), array("\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\""), "$0"), 1, -1)', trim($t)));
+for($i = count(($t = explode(';', $t))); --$i>=0;){
+ $w = $t[$i];
+ if(empty($w) or ($e = strpos($w, '=')) === false or !strlen(($a =  substr($w, $e+1)))){continue;}
+ $y = $n = array();
+ foreach(explode(',', $a) as $v){
+  if(!preg_match('`^([a-z:\-\*]+)(?:\((.*?)\))?`i', $v, $m)){continue;}
+  if(($x = strtolower($m[1])) == '-*'){$n['*'] = 1; continue;}
+  if($x[0] == '-'){$n[substr($x, 1)] = 1; continue;}
+  if(!isset($m[2])){$y[$x] = 1; continue;}
+  foreach(explode('/', $m[2]) as $m){
+   if(empty($m) or ($p = strpos($m, '=')) == 0 or $p < 5){$y[$x] = 1; continue;}
+   $y[$x][strtolower(substr($m, 0, $p))] = str_replace(array("\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08"), array(";", "|", "~", " ", ",", "/", "(", ")"), substr($m, $p+1));
+  }
+  if(isset($y[$x]['match']) && !htmLawed::hl_regex($y[$x]['match'])){unset($y[$x]['match']);}
+  if(isset($y[$x]['nomatch']) && !htmLawed::hl_regex($y[$x]['nomatch'])){unset($y[$x]['nomatch']);}
+ }
+ if(!count($y) && !count($n)){continue;}
+ foreach(explode(',', substr($w, 0, $e)) as $v){
+  if(!strlen(($v = strtolower($v)))){continue;}
+  if(count($y)){$s[$v] = $y;}
+  if(count($n)){$s[$v]['n'] = $n;}
+ }
+}
+return $s;
+// eof
+}
+
+public static function hl_tag($t){
+// tag/attribute handler
+global $C;
+$t = $t[0];
+// invalid < >
+if($t == '< '){return '&lt; ';}
+if($t == '>'){return '&gt;';}
+if(!preg_match('`^<(/?)([a-zA-Z][a-zA-Z1-6]*)([^>]*?)\s?>$`m', $t, $m)){
+ return str_replace(array('<', '>'), array('&lt;', '&gt;'), $t);
+}elseif(!isset($C['elements'][($e = strtolower($m[2]))])){
+ return (($C['keep_bad']%2) ? str_replace(array('<', '>'), array('&lt;', '&gt;'), $t) : '');
+}
+// attr string
+$a = str_replace(array("\n", "\r", "\t"), ' ', trim($m[3]));
+// tag transform
+static $eD = array('applet'=>1, 'center'=>1, 'dir'=>1, 'embed'=>1, 'font'=>1, 'isindex'=>1, 'menu'=>1, 's'=>1, 'strike'=>1, 'u'=>1); // Deprecated
+if($C['make_tag_strict'] && isset($eD[$e])){
+ $trt = htmLawed::hl_tag2($e, $a, $C['make_tag_strict']);
+ if(!$e){return (($C['keep_bad']%2) ? str_replace(array('<', '>'), array('&lt;', '&gt;'), $t) : '');}
+}
+// close tag
+static $eE = array('area'=>1, 'br'=>1, 'col'=>1, 'embed'=>1, 'hr'=>1, 'img'=>1, 'input'=>1, 'isindex'=>1, 'param'=>1); // Empty ele
+if(!empty($m[1])){
+ return (!isset($eE[$e]) ? (empty($C['hook_tag']) ? "</$e>" : $C['hook_tag']($e)) : (($C['keep_bad'])%2 ? str_replace(array('<', '>'), array('&lt;', '&gt;'), $t) : ''));
+}
+
+// open tag & attr
+static $aN = array('abbr'=>array('td'=>1, 'th'=>1), 'accept-charset'=>array('form'=>1), 'accept'=>array('form'=>1, 'input'=>1), 'accesskey'=>array('a'=>1, 'area'=>1, 'button'=>1, 'input'=>1, 'label'=>1, 'legend'=>1, 'textarea'=>1), 'action'=>array('form'=>1), 'align'=>array('caption'=>1, 'embed'=>1, 'applet'=>1, 'iframe'=>1, 'img'=>1, 'input'=>1, 'object'=>1, 'legend'=>1, 'table'=>1, 'hr'=>1, 'div'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'p'=>1, 'col'=>1, 'colgroup'=>1, 'tbody'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1), 'alt'=>array('applet'=>1, 'area'=>1, 'img'=>1, 'input'=>1), 'archive'=>array('applet'=>1, 'object'=>1), 'axis'=>array('td'=>1, 'th'=>1), 'bgcolor'=>array('embed'=>1, 'table'=>1, 'tr'=>1, 'td'=>1, 'th'=>1), 'border'=>array('table'=>1, 'img'=>1, 'object'=>1), 'bordercolor'=>array('table'=>1, 'td'=>1, 'tr'=>1), 'cellpadding'=>array('table'=>1), 'cellspacing'=>array('table'=>1), 'char'=>array('col'=>1, 'colgroup'=>1, 'tbody'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1), 'charoff'=>array('col'=>1, 'colgroup'=>1, 'tbody'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1), 'charset'=>array('a'=>1, 'script'=>1), 'checked'=>array('input'=>1), 'cite'=>array('blockquote'=>1, 'q'=>1, 'del'=>1, 'ins'=>1), 'classid'=>array('object'=>1), 'clear'=>array('br'=>1), 'code'=>array('applet'=>1), 'codebase'=>array('object'=>1, 'applet'=>1), 'codetype'=>array('object'=>1), 'color'=>array('font'=>1), 'cols'=>array('textarea'=>1), 'colspan'=>array('td'=>1, 'th'=>1), 'compact'=>array('dir'=>1, 'dl'=>1, 'menu'=>1, 'ol'=>1, 'ul'=>1), 'coords'=>array('area'=>1, 'a'=>1), 'data'=>array('object'=>1), 'datetime'=>array('del'=>1, 'ins'=>1), 'declare'=>array('object'=>1), 'defer'=>array('script'=>1), 'dir'=>array('bdo'=>1), 'disabled'=>array('button'=>1, 'input'=>1, 'optgroup'=>1, 'option'=>1, 'select'=>1, 'textarea'=>1), 'enctype'=>array('form'=>1), 'face'=>array('font'=>1), 'for'=>array('label'=>1), 'frame'=>array('table'=>1), 'frameborder'=>array('iframe'=>1), 'headers'=>array('td'=>1, 'th'=>1), 'height'=>array('embed'=>1, 'iframe'=>1, 'td'=>1, 'th'=>1, 'img'=>1, 'object'=>1, 'applet'=>1), 'href'=>array('a'=>1, 'area'=>1), 'hreflang'=>array('a'=>1), 'hspace'=>array('applet'=>1, 'img'=>1, 'object'=>1), 'ismap'=>array('img'=>1, 'input'=>1), 'label'=>array('option'=>1, 'optgroup'=>1), 'language'=>array('script'=>1), 'longdesc'=>array('img'=>1, 'iframe'=>1), 'marginheight'=>array('iframe'=>1), 'marginwidth'=>array('iframe'=>1), 'maxlength'=>array('input'=>1), 'method'=>array('form'=>1), 'model'=>array('embed'=>1), 'multiple'=>array('select'=>1), 'name'=>array('button'=>1, 'embed'=>1, 'textarea'=>1, 'applet'=>1, 'select'=>1, 'form'=>1, 'iframe'=>1, 'img'=>1, 'a'=>1, 'input'=>1, 'object'=>1, 'map'=>1, 'param'=>1), 'nohref'=>array('area'=>1), 'noshade'=>array('hr'=>1), 'nowrap'=>array('td'=>1, 'th'=>1), 'object'=>array('applet'=>1), 'onblur'=>array('a'=>1, 'area'=>1, 'button'=>1, 'input'=>1, 'label'=>1, 'select'=>1, 'textarea'=>1), 'onchange'=>array('input'=>1, 'select'=>1, 'textarea'=>1), 'onfocus'=>array('a'=>1, 'area'=>1, 'button'=>1, 'input'=>1, 'label'=>1, 'select'=>1, 'textarea'=>1), 'onreset'=>array('form'=>1), 'onselect'=>array('input'=>1, 'textarea'=>1), 'onsubmit'=>array('form'=>1), 'pluginspage'=>array('embed'=>1), 'pluginurl'=>array('embed'=>1), 'prompt'=>array('isindex'=>1), 'readonly'=>array('textarea'=>1, 'input'=>1), 'rel'=>array('a'=>1), 'rev'=>array('a'=>1), 'rows'=>array('textarea'=>1), 'rowspan'=>array('td'=>1, 'th'=>1), 'rules'=>array('table'=>1), 'scope'=>array('td'=>1, 'th'=>1), 'scrolling'=>array('iframe'=>1), 'selected'=>array('option'=>1), 'shape'=>array('area'=>1, 'a'=>1), 'size'=>array('hr'=>1, 'font'=>1, 'input'=>1, 'select'=>1), 'span'=>array('col'=>1, 'colgroup'=>1), 'src'=>array('embed'=>1, 'script'=>1, 'input'=>1, 'iframe'=>1, 'img'=>1), 'standby'=>array('object'=>1), 'start'=>array('ol'=>1), 'summary'=>array('table'=>1), 'tabindex'=>array('a'=>1, 'area'=>1, 'button'=>1, 'input'=>1, 'object'=>1, 'select'=>1, 'textarea'=>1), 'target'=>array('a'=>1, 'area'=>1, 'form'=>1), 'type'=>array('a'=>1, 'embed'=>1, 'object'=>1, 'param'=>1, 'script'=>1, 'input'=>1, 'li'=>1, 'ol'=>1, 'ul'=>1, 'button'=>1), 'usemap'=>array('img'=>1, 'input'=>1, 'object'=>1), 'valign'=>array('col'=>1, 'colgroup'=>1, 'tbody'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1), 'value'=>array('input'=>1, 'option'=>1, 'param'=>1, 'button'=>1, 'li'=>1), 'valuetype'=>array('param'=>1), 'vspace'=>array('applet'=>1, 'img'=>1, 'object'=>1), 'width'=>array('embed'=>1, 'hr'=>1, 'iframe'=>1, 'img'=>1, 'object'=>1, 'table'=>1, 'td'=>1, 'th'=>1, 'applet'=>1, 'col'=>1, 'colgroup'=>1, 'pre'=>1), 'wmode'=>array('embed'=>1), 'xml:space'=>array('pre'=>1, 'script'=>1, 'style'=>1)); // Ele-specific
+static $aNE = array('checked'=>1, 'compact'=>1, 'declare'=>1, 'defer'=>1, 'disabled'=>1, 'ismap'=>1, 'multiple'=>1, 'nohref'=>1, 'noresize'=>1, 'noshade'=>1, 'nowrap'=>1, 'readonly'=>1, 'selected'=>1); // Empty
+static $aNP = array('action'=>1, 'cite'=>1, 'classid'=>1, 'codebase'=>1, 'data'=>1, 'href'=>1, 'longdesc'=>1, 'model'=>1, 'pluginspage'=>1, 'pluginurl'=>1, 'usemap'=>1); // Need scheme check; excludes style, on* & src
+static $aNU = array('class'=>array('param'=>1, 'script'=>1), 'dir'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'iframe'=>1, 'param'=>1, 'script'=>1), 'id'=>array('script'=>1), 'lang'=>array('applet'=>1, 'br'=>1, 'iframe'=>1, 'param'=>1, 'script'=>1), 'xml:lang'=>array('applet'=>1, 'br'=>1, 'iframe'=>1, 'param'=>1, 'script'=>1), 'onclick'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'ondblclick'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onkeydown'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onkeypress'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onkeyup'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onmousedown'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onmousemove'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onmouseout'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onmouseover'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'onmouseup'=>array('applet'=>1, 'bdo'=>1, 'br'=>1, 'font'=>1, 'iframe'=>1, 'isindex'=>1, 'param'=>1, 'script'=>1), 'style'=>array('param'=>1, 'script'=>1), 'title'=>array('param'=>1, 'script'=>1)); // Univ & exceptions
+
+if($C['lc_std_val']){
+ // predef attr vals for $eAL & $aNE ele
+ static $aNL = array('all'=>1, 'baseline'=>1, 'bottom'=>1, 'button'=>1, 'center'=>1, 'char'=>1, 'checkbox'=>1, 'circle'=>1, 'col'=>1, 'colgroup'=>1, 'cols'=>1, 'data'=>1, 'default'=>1, 'file'=>1, 'get'=>1, 'groups'=>1, 'hidden'=>1, 'image'=>1, 'justify'=>1, 'left'=>1, 'ltr'=>1, 'middle'=>1, 'none'=>1, 'object'=>1, 'password'=>1, 'poly'=>1, 'post'=>1, 'preserve'=>1, 'radio'=>1, 'rect'=>1, 'ref'=>1, 'reset'=>1, 'right'=>1, 'row'=>1, 'rowgroup'=>1, 'rows'=>1, 'rtl'=>1, 'submit'=>1, 'text'=>1, 'top'=>1);
+ static $eAL = array('a'=>1, 'area'=>1, 'bdo'=>1, 'button'=>1, 'col'=>1, 'form'=>1, 'img'=>1, 'input'=>1, 'object'=>1, 'optgroup'=>1, 'option'=>1, 'param'=>1, 'script'=>1, 'select'=>1, 'table'=>1, 'td'=>1, 'tfoot'=>1, 'th'=>1, 'thead'=>1, 'tr'=>1, 'xml:space'=>1);
+ $lcase = isset($eAL[$e]) ? 1 : 0;
+}
+
+$depTr = 0;
+if($C['no_deprecated_attr']){
+ // dep attr:applicable ele
+ static $aND = array('align'=>array('caption'=>1, 'div'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'hr'=>1, 'img'=>1, 'input'=>1, 'legend'=>1, 'object'=>1, 'p'=>1, 'table'=>1), 'bgcolor'=>array('table'=>1, 'td'=>1, 'th'=>1, 'tr'=>1), 'border'=>array('img'=>1, 'object'=>1), 'bordercolor'=>array('table'=>1, 'td'=>1, 'tr'=>1), 'clear'=>array('br'=>1), 'compact'=>array('dl'=>1, 'ol'=>1, 'ul'=>1), 'height'=>array('td'=>1, 'th'=>1), 'hspace'=>array('img'=>1, 'object'=>1), 'language'=>array('script'=>1), 'name'=>array('a'=>1, 'form'=>1, 'iframe'=>1, 'img'=>1, 'map'=>1), 'noshade'=>array('hr'=>1), 'nowrap'=>array('td'=>1, 'th'=>1), 'size'=>array('hr'=>1), 'start'=>array('ol'=>1), 'type'=>array('li'=>1, 'ol'=>1, 'ul'=>1), 'value'=>array('li'=>1), 'vspace'=>array('img'=>1, 'object'=>1), 'width'=>array('hr'=>1, 'pre'=>1, 'td'=>1, 'th'=>1));
+ static $eAD = array('a'=>1, 'br'=>1, 'caption'=>1, 'div'=>1, 'dl'=>1, 'form'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'hr'=>1, 'iframe'=>1, 'img'=>1, 'input'=>1, 'legend'=>1, 'li'=>1, 'map'=>1, 'object'=>1, 'ol'=>1, 'p'=>1, 'pre'=>1, 'script'=>1, 'table'=>1, 'td'=>1, 'th'=>1, 'tr'=>1, 'ul'=>1);
+ $depTr = isset($eAD[$e]) ? 1 : 0;
+}
+
+// attr name-vals
+if(strpos($a, "\x01") !== false){$a = preg_replace('`\x01[^\x01]*\x01`', '', $a);} // No comment/CDATA sec
+$mode = 0; $a = trim($a, ' /'); $aA = array();
+while(strlen($a)){
+ $w = 0;
+ switch($mode){
+  case 0: // Name
+   if(preg_match('`^[a-zA-Z][\-a-zA-Z:]+`', $a, $m)){
+    $nm = strtolower($m[0]);
+    $w = $mode = 1; $a = ltrim(substr_replace($a, '', 0, strlen($m[0])));
+   }
+  break; case 1:
+   if($a[0] == '='){ // =
+    $w = 1; $mode = 2; $a = ltrim($a, '= ');
+   }else{ // No val
+    $w = 1; $mode = 0; $a = ltrim($a);
+    $aA[$nm] = '';
+   }
+  break; case 2: // Val
+   if(preg_match('`^((?:"[^"]*")|(?:\'[^\']*\')|(?:\s*[^\s"\']+))(.*)`', $a, $m)){
+    $a = ltrim($m[2]); $m = $m[1]; $w = 1; $mode = 0;
+    $aA[$nm] = trim(($m[0] == '"' or $m[0] == '\'') ? substr($m, 1, -1) : $m);
+   }
+  break;
+ }
+ if($w == 0){ // Parse errs, deal with space, " & '
+  $a = preg_replace('`^(?:"[^"]*("|$)|\'[^\']*(\'|$)|\S)*\s*`', '', $a);
+  $mode = 0;
+ }
+}
+if($mode == 1){$aA[$nm] = '';}
+
+// clean attrs
+global $S;
+$rl = isset($S[$e]) ? $S[$e] : array();
+$a = array(); $nfr = 0;
+foreach($aA as $k=>$v){
+ if(((isset($C['deny_attribute']['*']) ? isset($C['deny_attribute'][$k]) : !isset($C['deny_attribute'][$k])) && (isset($aN[$k][$e]) or (isset($aNU[$k]) && !isset($aNU[$k][$e]))) && !isset($rl['n'][$k]) && !isset($rl['n']['*'])) or isset($rl[$k])){
+  if(isset($aNE[$k])){$v = $k;}
+  elseif(!empty($lcase) && (($e != 'button' or $e != 'input') or $k == 'type')){ // Rather loose but ?not cause issues
+   $v = (isset($aNL[($v2 = strtolower($v))])) ? $v2 : $v;
+  }
+  if($k == 'style' && !$C['style_pass']){
+   if(false !== strpos($v, '&#')){
+    static $sC = array('&#x20;'=>' ', '&#32;'=>' ', '&#x45;'=>'e', '&#69;'=>'e', '&#x65;'=>'e', '&#101;'=>'e', '&#x58;'=>'x', '&#88;'=>'x', '&#x78;'=>'x', '&#120;'=>'x', '&#x50;'=>'p', '&#80;'=>'p', '&#x70;'=>'p', '&#112;'=>'p', '&#x53;'=>'s', '&#83;'=>'s', '&#x73;'=>'s', '&#115;'=>'s', '&#x49;'=>'i', '&#73;'=>'i', '&#x69;'=>'i', '&#105;'=>'i', '&#x4f;'=>'o', '&#79;'=>'o', '&#x6f;'=>'o', '&#111;'=>'o', '&#x4e;'=>'n', '&#78;'=>'n', '&#x6e;'=>'n', '&#110;'=>'n', '&#x55;'=>'u', '&#85;'=>'u', '&#x75;'=>'u', '&#117;'=>'u', '&#x52;'=>'r', '&#82;'=>'r', '&#x72;'=>'r', '&#114;'=>'r', '&#x4c;'=>'l', '&#76;'=>'l', '&#x6c;'=>'l', '&#108;'=>'l', '&#x28;'=>'(', '&#40;'=>'(', '&#x29;'=>')', '&#41;'=>')', '&#x20;'=>':', '&#32;'=>':', '&#x22;'=>'"', '&#34;'=>'"', '&#x27;'=>"'", '&#39;'=>"'", '&#x2f;'=>'/', '&#47;'=>'/', '&#x2a;'=>'*', '&#42;'=>'*', '&#x5c;'=>'\\', '&#92;'=>'\\');
+    $v = strtr($v, $sC);
+   }
+   $v = preg_replace_callback('`(url(?:\()(?: )*(?:\'|"|&(?:quot|apos);)?)(.+?)((?:\'|"|&(?:quot|apos);)?(?: )*(?:\)))`iS', 'htmLawed::hl_prot', $v);
+   $v = !$C['css_expression'] ? preg_replace('`expression`i', ' ', preg_replace('`\\\\\S|(/|(%2f))(\*|(%2a))`i', ' ', $v)) : $v;
+  }elseif(isset($aNP[$k]) or strpos($k, 'src') !== false or $k[0] == 'o'){
+   $v = str_replace("\xad", ' ', (strpos($v, '&') !== false ? str_replace(array('&#xad;', '&#173;', '&shy;'), ' ', $v) : $v));
+   $v = htmLawed::hl_prot($v, $k);
+   if($k == 'href'){ // X-spam
+    if($C['anti_mail_spam'] && strpos($v, 'mailto:') === 0){
+     $v = str_replace('@', htmlspecialchars($C['anti_mail_spam']), $v);
+    }elseif($C['anti_link_spam']){
+     $r1 = $C['anti_link_spam'][1];
+     if(!empty($r1) && preg_match($r1, $v)){continue;}
+     $r0 = $C['anti_link_spam'][0];
+     if(!empty($r0) && preg_match($r0, $v)){
+      if(isset($a['rel'])){
+       if(!preg_match('`\bnofollow\b`i', $a['rel'])){$a['rel'] .= ' nofollow';}
+      }elseif(isset($aA['rel'])){
+       if(!preg_match('`\bnofollow\b`i', $aA['rel'])){$nfr = 1;}
+      }else{$a['rel'] = 'nofollow';}
+     }
+    }
+   }
+  }
+  if(isset($rl[$k]) && is_array($rl[$k]) && ($v = htmLawed::hl_attrval($v, $rl[$k])) === 0){continue;}
+  $a[$k] = str_replace('"', '&quot;', $v);
+ }
+}
+if($nfr){$a['rel'] = isset($a['rel']) ? $a['rel']. ' nofollow' : 'nofollow';}
+
+// rqd attr
+static $eAR = array('area'=>array('alt'=>'area'), 'bdo'=>array('dir'=>'ltr'), 'form'=>array('action'=>''), 'img'=>array('src'=>'', 'alt'=>'image'), 'map'=>array('name'=>''), 'optgroup'=>array('label'=>''), 'param'=>array('name'=>''), 'script'=>array('type'=>'text/javascript'), 'textarea'=>array('rows'=>'10', 'cols'=>'50'));
+if(isset($eAR[$e])){
+ foreach($eAR[$e] as $k=>$v){
+  if(!isset($a[$k])){$a[$k] = isset($v[0]) ? $v : $k;}
+ }
+}
+
+// depr attrs
+if($depTr){
+ $c = array();
+ foreach($a as $k=>$v){
+  if($k == 'style' or !isset($aND[$k][$e])){continue;}
+  if($k == 'align'){
+   unset($a['align']);
+   if($e == 'img' && ($v == 'left' or $v == 'right')){$c[] = 'float: '. $v;}
+   elseif(($e == 'div' or $e == 'table') && $v == 'center'){$c[] = 'margin: auto';}
+   else{$c[] = 'text-align: '. $v;}
+  }elseif($k == 'bgcolor'){
+   unset($a['bgcolor']);
+   $c[] = 'background-color: '. $v;
+  }elseif($k == 'border'){
+   unset($a['border']); $c[] = "border: {$v}px";
+  }elseif($k == 'bordercolor'){
+   unset($a['bordercolor']); $c[] = 'border-color: '. $v;
+  }elseif($k == 'clear'){
+   unset($a['clear']); $c[] = 'clear: '. ($v != 'all' ? $v : 'both');
+  }elseif($k == 'compact'){
+   unset($a['compact']); $c[] = 'font-size: 85%';
+  }elseif($k == 'height' or $k == 'width'){
+   unset($a[$k]); $c[] = $k. ': '. ($v[0] != '*' ? $v. (ctype_digit($v) ? 'px' : '') : 'auto');
+  }elseif($k == 'hspace'){
+   unset($a['hspace']); $c[] = "margin-left: {$v}px; margin-right: {$v}px";
+  }elseif($k == 'language' && !isset($a['type'])){
+   unset($a['language']);
+   $a['type'] = 'text/'. strtolower($v);
+  }elseif($k == 'name'){
+   if($C['no_deprecated_attr'] == 2 or ($e != 'a' && $e != 'map')){unset($a['name']);}
+   if(!isset($a['id']) && preg_match('`[a-zA-Z][a-zA-Z\d.:_\-]*`', $v)){$a['id'] = $v;}
+  }elseif($k == 'noshade'){
+   unset($a['noshade']); $c[] = 'border-style: none; border: 0; background-color: gray; color: gray';
+  }elseif($k == 'nowrap'){
+   unset($a['nowrap']); $c[] = 'white-space: nowrap';
+  }elseif($k == 'size'){
+   unset($a['size']); $c[] = 'size: '. $v. 'px';
+  }elseif($k == 'start' or $k == 'value'){
+   unset($a[$k]);
+  }elseif($k == 'type'){
+   unset($a['type']);
+   static $ol_type = array('i'=>'lower-roman', 'I'=>'upper-roman', 'a'=>'lower-latin', 'A'=>'upper-latin', '1'=>'decimal');
+   $c[] = 'list-style-type: '. (isset($ol_type[$v]) ? $ol_type[$v] : 'decimal');
+  }elseif($k == 'vspace'){
+   unset($a['vspace']); $c[] = "margin-top: {$v}px; margin-bottom: {$v}px";
+  }
+ }
+ if(count($c)){
+  $c = implode('; ', $c);
+  $a['style'] = isset($a['style']) ? rtrim($a['style'], ' ;'). '; '. $c. ';': $c. ';';
+ }
+}
+// unique ID
+if($C['unique_ids'] && isset($a['id'])){
+ if(!preg_match('`^[A-Za-z][A-Za-z0-9_\-.:]*$`', ($id = $a['id'])) or (isset($GLOBALS['hl_Ids'][$id]) && $C['unique_ids'] == 1)){unset($a['id']);
+ }else{
+  while(isset($GLOBALS['hl_Ids'][$id])){$id = $C['unique_ids']. $id;}
+  $GLOBALS['hl_Ids'][($a['id'] = $id)] = 1;
+ }
+}
+// xml:lang
+if($C['xml:lang'] && isset($a['lang'])){
+ $a['xml:lang'] = isset($a['xml:lang']) ? $a['xml:lang'] : $a['lang'];
+ if($C['xml:lang'] == 2){unset($a['lang']);}
+}
+// for transformed tag
+if(!empty($trt)){
+ $a['style'] = isset($a['style']) ? rtrim($a['style'], ' ;'). '; '. $trt : $trt;
+}
+// return with empty ele /
+if(empty($C['hook_tag'])){
+ $aA = '';
+ foreach($a as $k=>$v){$aA .= " {$k}=\"{$v}\"";}
+ return "<{$e}{$aA}". (isset($eE[$e]) ? ' /' : ''). '>';
+}
+else{return $C['hook_tag']($e, $a);}
+// eof
+}
+
+public static function hl_tag2(&$e, &$a, $t=1){
+// transform tag
+if($e == 'center'){$e = 'div'; return 'text-align: center;';}
+if($e == 'dir' or $e == 'menu'){$e = 'ul'; return '';}
+if($e == 's' or $e == 'strike'){$e = 'span'; return 'text-decoration: line-through;';}
+if($e == 'u'){$e = 'span'; return 'text-decoration: underline;';}
+static $fs = array('0'=>'xx-small', '1'=>'xx-small', '2'=>'small', '3'=>'medium', '4'=>'large', '5'=>'x-large', '6'=>'xx-large', '7'=>'300%', '-1'=>'smaller', '-2'=>'60%', '+1'=>'larger', '+2'=>'150%', '+3'=>'200%', '+4'=>'300%');
+if($e == 'font'){
+ $a2 = '';
+ if(preg_match('`face\s*=\s*(\'|")([^=]+?)\\1`i', $a, $m) or preg_match('`face\s*=(\s*)(\S+)`i', $a, $m)){
+  $a2 .= ' font-family: '. str_replace('"', '\'', trim($m[2])). ';';
+ }
+ if(preg_match('`color\s*=\s*(\'|")?(.+?)(\\1|\s|$)`i', $a, $m)){
+  $a2 .= ' color: '. trim($m[2]). ';';
+ }
+ if(preg_match('`size\s*=\s*(\'|")?(.+?)(\\1|\s|$)`i', $a, $m) && isset($fs[($m = trim($m[2]))])){
+  $a2 .= ' font-size: '. $fs[$m]. ';';
+ }
+ $e = 'span'; return ltrim($a2);
+}
+if($t == 2){$e = 0; return 0;}
+return '';
+// eof
+}
+
+public static function hl_tidy($t, $w, $p){
+// Tidy/compact HTM
+if(strpos(' pre,script,textarea', "$p,")){return $t;}
+$t = str_replace(' </', '</', preg_replace(array('`(<\w[^>]*(?<!/)>)\s+`', '`\s+`', '`(<\w[^>]*(?<!/)>) `'), array(' $1', ' ', '$1'), preg_replace_callback(array('`(<(!\[CDATA\[))(.+?)(\]\]>)`sm', '`(<(!--))(.+?)(-->)`sm', '`(<(pre|script|textarea)[^>]*?>)(.+?)(</\2>)`sm'), create_function('$m', 'return $m[1]. str_replace(array("<", ">", "\n", "\r", "\t", " "), array("\x01", "\x02", "\x03", "\x04", "\x05", "\x07"), $m[3]). $m[4];'), $t)));
+if(($w = strtolower($w)) == -1){
+ return str_replace(array("\x01", "\x02", "\x03", "\x04", "\x05", "\x07"), array('<', '>', "\n", "\r", "\t", ' '), $t);
+}
+$s = strpos(" $w", 't') ? "\t" : ' ';
+$s = preg_match('`\d`', $w, $m) ? str_repeat($s, $m[0]) : str_repeat($s, ($s == "\t" ? 1 : 2));
+$N = preg_match('`[ts]([1-9])`', $w, $m) ? $m[1] : 0;
+$a = array('br'=>1);
+$b = array('button'=>1, 'input'=>1, 'option'=>1);
+$c = array('caption'=>1, 'dd'=>1, 'dt'=>1, 'h1'=>1, 'h2'=>1, 'h3'=>1, 'h4'=>1, 'h5'=>1, 'h6'=>1, 'isindex'=>1, 'label'=>1, 'legend'=>1, 'li'=>1, 'object'=>1, 'p'=>1, 'pre'=>1, 'td'=>1, 'textarea'=>1, 'th'=>1);
+$d = array('address'=>1, 'blockquote'=>1, 'center'=>1, 'colgroup'=>1, 'dir'=>1, 'div'=>1, 'dl'=>1, 'fieldset'=>1, 'form'=>1, 'hr'=>1, 'iframe'=>1, 'map'=>1, 'menu'=>1, 'noscript'=>1, 'ol'=>1, 'optgroup'=>1, 'rbc'=>1, 'rtc'=>1, 'ruby'=>1, 'script'=>1, 'select'=>1, 'table'=>1, 'tbody'=>1, 'tfoot'=>1, 'thead'=>1, 'tr'=>1, 'ul'=>1);
+$T = explode('<', $t);
+$X = 1;
+while($X){
+ $n = $N;
+ $t = $T;
+ ob_start();
+ if(isset($d[$p])){echo str_repeat($s, ++$n);}
+ echo ltrim(array_shift($t));
+ for($i=-1, $j=count($t); ++$i<$j;){
+  $r = ''; list($e, $r) = explode('>', $t[$i]);
+  $x = $e[0] == '/' ? 0 : (substr($e, -1) == '/' ? 1 : ($e[0] != '!' ? 2 : -1));
+  $y = !$x ? ltrim($e, '/') : ($x > 0 ? substr($e, 0, strcspn($e, ' ')) : 0);
+  $e = "<$e>"; 
+  if(isset($d[$y])){
+   if(!$x){
+    if($n){echo "\n", str_repeat($s, --$n), "$e\n", str_repeat($s, $n);}
+    else{++$N; ob_end_clean(); continue 2;}
+   }
+   else{echo "\n", str_repeat($s, $n), "$e\n", str_repeat($s, ($x != 1 ? ++$n : $n));}
+   echo ltrim($r); continue;
+  }
+  $f = "\n". str_repeat($s, $n);
+  if(isset($c[$y])){
+   if(!$x){echo $e, $f, ltrim($r);}
+   else{echo $f, $e, $r;}
+  }elseif(isset($b[$y])){echo $f, $e, $r;
+  }elseif(isset($a[$y])){echo $e, $f, ltrim($r);
+  }elseif(!$y){echo $f, $e, $f, ltrim($r);
+  }else{echo $e, $r;}
+ }
+ $X = 0;
+}
+$t = preg_replace('`[\n]\s*?[\n]+`', "\n", ob_get_contents());
+ob_end_clean();
+if(($l = strpos(" $w", 'r') ? (strpos(" $w", 'n') ? "\r\n" : "\r") : 0)){
+ $t = str_replace("\n", $l, $t);
+}
+return str_replace(array("\x01", "\x02", "\x03", "\x04", "\x05", "\x07"), array('<', '>', "\n", "\r", "\t", ' '), $t);
+// eof
+}
+
+public static function hl_version(){
+// rel
+return '1.1.14';
+// eof
+}
+
+public static function kses($t, $h, $p=array('http', 'https', 'ftp', 'news', 'nntp', 'telnet', 'gopher', 'mailto')){
+// kses compat
+foreach($h as $k=>$v){
+ $h[$k]['n']['*'] = 1;
+}
+$C['cdata'] = $C['comment'] = $C['make_tag_strict'] = $C['no_deprecated_attr'] = $C['unique_ids'] = 0;
+$C['keep_bad'] = 1;
+$C['elements'] = count($h) ? strtolower(implode(',', array_keys($h))) : '-*';
+$C['hook'] = 'htmLawed::kses_hook';
+$C['schemes'] = '*:'. implode(',', $p);
+return htmLawed::hl($t, $C, $h);
+// eof
+}
+
+public static function kses_hook($t, &$C, &$S){
+// kses compat
+return $t;
+// eof
+}
+// end class
+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/html5/Data.php b/inc/3rdparty/libraries/html5/Data.php
new file mode 100644
index 00000000..497345f4
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/Data.php
@@ -0,0 +1,114 @@
+<?php
+
+// warning: this file is encoded in UTF-8!
+
+class HTML5_Data
+{
+
+    // at some point this should be moved to a .ser file. Another
+    // possible optimization is to give UTF-8 bytes, not Unicode
+    // codepoints
+    // XXX: Not quite sure why it's named this; this is
+    // actually the numeric entity dereference table.
+    protected static $realCodepointTable = array(
+        0x00 => 0xFFFD, // REPLACEMENT CHARACTER
+        0x0D => 0x000A, // LINE FEED (LF)
+        0x80 => 0x20AC, // EURO SIGN ('€')
+        0x81 => 0x0081, // <control>
+        0x82 => 0x201A, // SINGLE LOW-9 QUOTATION MARK ('‚')
+        0x83 => 0x0192, // LATIN SMALL LETTER F WITH HOOK ('ƒ')
+        0x84 => 0x201E, // DOUBLE LOW-9 QUOTATION MARK ('„')
+        0x85 => 0x2026, // HORIZONTAL ELLIPSIS ('…')
+        0x86 => 0x2020, // DAGGER ('†')
+        0x87 => 0x2021, // DOUBLE DAGGER ('‡')
+        0x88 => 0x02C6, // MODIFIER LETTER CIRCUMFLEX ACCENT ('ˆ')
+        0x89 => 0x2030, // PER MILLE SIGN ('‰')
+        0x8A => 0x0160, // LATIN CAPITAL LETTER S WITH CARON ('Š')
+        0x8B => 0x2039, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK ('‹')
+        0x8C => 0x0152, // LATIN CAPITAL LIGATURE OE ('Œ')
+        0x8D => 0x008D, // <control>
+        0x8E => 0x017D, // LATIN CAPITAL LETTER Z WITH CARON ('Ž')
+        0x8F => 0x008F, // <control>
+        0x90 => 0x0090, // <control>
+        0x91 => 0x2018, // LEFT SINGLE QUOTATION MARK ('‘')
+        0x92 => 0x2019, // RIGHT SINGLE QUOTATION MARK ('’')
+        0x93 => 0x201C, // LEFT DOUBLE QUOTATION MARK ('“')
+        0x94 => 0x201D, // RIGHT DOUBLE QUOTATION MARK ('”')
+        0x95 => 0x2022, // BULLET ('•')
+        0x96 => 0x2013, // EN DASH ('–')
+        0x97 => 0x2014, // EM DASH ('—')
+        0x98 => 0x02DC, // SMALL TILDE ('˜')
+        0x99 => 0x2122, // TRADE MARK SIGN ('™')
+        0x9A => 0x0161, // LATIN SMALL LETTER S WITH CARON ('š')
+        0x9B => 0x203A, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK ('›')
+        0x9C => 0x0153, // LATIN SMALL LIGATURE OE ('œ')
+        0x9D => 0x009D, // <control>
+        0x9E => 0x017E, // LATIN SMALL LETTER Z WITH CARON ('ž')
+        0x9F => 0x0178, // LATIN CAPITAL LETTER Y WITH DIAERESIS ('Ÿ')
+    );
+
+    protected static $namedCharacterReferences;
+
+    protected static $namedCharacterReferenceMaxLength;
+
+    /**
+     * Returns the "real" Unicode codepoint of a malformed character
+     * reference.
+     */
+    public static function getRealCodepoint($ref) {
+        if (!isset(self::$realCodepointTable[$ref])) return false;
+        else return self::$realCodepointTable[$ref];
+    }
+
+    public static function getNamedCharacterReferences() {
+        if (!self::$namedCharacterReferences) {
+            self::$namedCharacterReferences = unserialize(
+                file_get_contents(dirname(__FILE__) . '/named-character-references.ser'));
+        }
+        return self::$namedCharacterReferences;
+    }
+
+    /**
+     * Converts a Unicode codepoint to sequence of UTF-8 bytes.
+     * @note Shamelessly stolen from HTML Purifier, which is also
+     *       shamelessly stolen from Feyd (which is in public domain).
+     */
+    public static function utf8chr($code) {
+        /* We don't care: we live dangerously
+         * if($code > 0x10FFFF or $code < 0x0 or
+          ($code >= 0xD800 and $code <= 0xDFFF) ) {
+            // bits are set outside the "valid" range as defined
+            // by UNICODE 4.1.0
+            return "\xEF\xBF\xBD";
+          }*/
+
+        $x = $y = $z = $w = 0;
+        if ($code < 0x80) {
+            // regular ASCII character
+            $x = $code;
+        } else {
+            // set up bits for UTF-8
+            $x = ($code & 0x3F) | 0x80;
+            if ($code < 0x800) {
+               $y = (($code & 0x7FF) >> 6) | 0xC0;
+            } else {
+                $y = (($code & 0xFC0) >> 6) | 0x80;
+                if($code < 0x10000) {
+                    $z = (($code >> 12) & 0x0F) | 0xE0;
+                } else {
+                    $z = (($code >> 12) & 0x3F) | 0x80;
+                    $w = (($code >> 18) & 0x07) | 0xF0;
+                }
+            }
+        }
+        // set up the actual character
+        $ret = '';
+        if($w) $ret .= chr($w);
+        if($z) $ret .= chr($z);
+        if($y) $ret .= chr($y);
+        $ret .= chr($x);
+
+        return $ret;
+    }
+
+}
diff --git a/inc/3rdparty/libraries/html5/InputStream.php b/inc/3rdparty/libraries/html5/InputStream.php
new file mode 100644
index 00000000..f98b4272
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/InputStream.php
@@ -0,0 +1,284 @@
+<?php
+
+/*
+
+Copyright 2009 Geoffrey Sneddon <http://gsnedders.com/>
+
+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.
+
+*/
+
+// Some conventions:
+// /* */ indicates verbatim text from the HTML 5 specification
+// // indicates regular comments
+
+class HTML5_InputStream {
+    /**
+     * The string data we're parsing.
+     */
+    private $data;
+
+    /**
+     * The current integer byte position we are in $data
+     */
+    private $char;
+
+    /**
+     * Length of $data; when $char === $data, we are at the end-of-file.
+     */
+    private $EOF;
+
+    /**
+     * Parse errors.
+     */
+    public $errors = array();
+
+    /**
+     * @param $data Data to parse
+     */
+    public function __construct($data) {
+
+        /* Given an encoding, the bytes in the input stream must be
+        converted to Unicode characters for the tokeniser, as
+        described by the rules for that encoding, except that the
+        leading U+FEFF BYTE ORDER MARK character, if any, must not
+        be stripped by the encoding layer (it is stripped by the rule below).
+
+        Bytes or sequences of bytes in the original byte stream that
+        could not be converted to Unicode characters must be converted
+        to U+FFFD REPLACEMENT CHARACTER code points. */
+
+        // XXX currently assuming input data is UTF-8; once we
+        // build encoding detection this will no longer be the case
+        //
+        // We previously had an mbstring implementation here, but that
+        // implementation is heavily non-conforming, so it's been
+        // omitted.
+        if (extension_loaded('iconv')) {
+            // non-conforming
+            $data = @iconv('UTF-8', 'UTF-8//IGNORE', $data);
+        } else {
+            // we can make a conforming native implementation
+            throw new Exception('Not implemented, please install mbstring or iconv');
+        }
+
+        /* One leading U+FEFF BYTE ORDER MARK character must be
+        ignored if any are present. */
+        if (substr($data, 0, 3) === "\xEF\xBB\xBF") {
+            $data = substr($data, 3);
+        }
+
+        /* All U+0000 NULL characters in the input must be replaced
+        by U+FFFD REPLACEMENT CHARACTERs. Any occurrences of such
+        characters is a parse error. */
+        for ($i = 0, $count = substr_count($data, "\0"); $i < $count; $i++) {
+            $this->errors[] = array(
+                'type' => HTML5_Tokenizer::PARSEERROR,
+                'data' => 'null-character'
+            );
+        }
+        /* U+000D CARRIAGE RETURN (CR) characters and U+000A LINE FEED
+        (LF) characters are treated specially. Any CR characters
+        that are followed by LF characters must be removed, and any
+        CR characters not followed by LF characters must be converted
+        to LF characters. Thus, newlines in HTML DOMs are represented
+        by LF characters, and there are never any CR characters in the
+        input to the tokenization stage. */
+        $data = str_replace(
+            array(
+                "\0",
+                "\r\n",
+                "\r"
+            ),
+            array(
+                "\xEF\xBF\xBD",
+                "\n",
+                "\n"
+            ),
+            $data
+        );
+
+        /* Any occurrences of any characters in the ranges U+0001 to
+        U+0008, U+000B,  U+000E to U+001F,  U+007F  to U+009F,
+        U+D800 to U+DFFF , U+FDD0 to U+FDEF, and
+        characters U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, U+2FFFF,
+        U+3FFFE, U+3FFFF, U+4FFFE, U+4FFFF, U+5FFFE, U+5FFFF, U+6FFFE,
+        U+6FFFF, U+7FFFE, U+7FFFF, U+8FFFE, U+8FFFF, U+9FFFE, U+9FFFF,
+        U+AFFFE, U+AFFFF, U+BFFFE, U+BFFFF, U+CFFFE, U+CFFFF, U+DFFFE,
+        U+DFFFF, U+EFFFE, U+EFFFF, U+FFFFE, U+FFFFF, U+10FFFE, and
+        U+10FFFF are parse errors. (These are all control characters
+        or permanently undefined Unicode characters.) */
+        // Check PCRE is loaded.
+        if (extension_loaded('pcre')) {
+            $count = preg_match_all(
+                '/(?:
+                    [\x01-\x08\x0B\x0E-\x1F\x7F] # U+0001 to U+0008, U+000B,  U+000E to U+001F and U+007F
+                |
+                    \xC2[\x80-\x9F] # U+0080 to U+009F
+                |
+                    \xED(?:\xA0[\x80-\xFF]|[\xA1-\xBE][\x00-\xFF]|\xBF[\x00-\xBF]) # U+D800 to U+DFFFF
+                |
+                    \xEF\xB7[\x90-\xAF] # U+FDD0 to U+FDEF
+                |
+                    \xEF\xBF[\xBE\xBF] # U+FFFE and U+FFFF
+                |
+                    [\xF0-\xF4][\x8F-\xBF]\xBF[\xBE\xBF] # U+nFFFE and U+nFFFF (1 <= n <= 10_{16})
+                )/x',
+                $data,
+                $matches
+            );
+            for ($i = 0; $i < $count; $i++) {
+                $this->errors[] = array(
+                    'type' => HTML5_Tokenizer::PARSEERROR,
+                    'data' => 'invalid-codepoint'
+                );
+            }
+        } else {
+            // XXX: Need non-PCRE impl, probably using substr_count
+        }
+
+        $this->data = $data;
+        $this->char = 0;
+        $this->EOF  = strlen($data);
+    }
+
+    /**
+     * Returns the current line that the tokenizer is at.
+     */
+    public function getCurrentLine() {
+        // Check the string isn't empty
+        if($this->EOF) {
+            // Add one to $this->char because we want the number for the next
+            // byte to be processed.
+            return substr_count($this->data, "\n", 0, min($this->char, $this->EOF)) + 1;
+        } else {
+            // If the string is empty, we are on the first line (sorta).
+            return 1;
+        }
+    }
+
+    /**
+     * Returns the current column of the current line that the tokenizer is at.
+     */
+    public function getColumnOffset() {
+        // strrpos is weird, and the offset needs to be negative for what we
+        // want (i.e., the last \n before $this->char). This needs to not have
+        // one (to make it point to the next character, the one we want the
+        // position of) added to it because strrpos's behaviour includes the
+        // final offset byte.
+        $lastLine = strrpos($this->data, "\n", $this->char - 1 - strlen($this->data));
+
+        // However, for here we want the length up until the next byte to be
+        // processed, so add one to the current byte ($this->char).
+        if($lastLine !== false) {
+            $findLengthOf = substr($this->data, $lastLine + 1, $this->char - 1 - $lastLine);
+        } else {
+            $findLengthOf = substr($this->data, 0, $this->char);
+        }
+
+        // Get the length for the string we need.
+        if(extension_loaded('iconv')) {
+            return iconv_strlen($findLengthOf, 'utf-8');
+        } elseif(extension_loaded('mbstring')) {
+            return mb_strlen($findLengthOf, 'utf-8');
+        } elseif(extension_loaded('xml')) {
+            return strlen(utf8_decode($findLengthOf));
+        } else {
+            $count = count_chars($findLengthOf);
+            // 0x80 = 0x7F - 0 + 1 (one added to get inclusive range)
+            // 0x33 = 0xF4 - 0x2C + 1 (one added to get inclusive range)
+            return array_sum(array_slice($count, 0, 0x80)) +
+                   array_sum(array_slice($count, 0xC2, 0x33));
+        }
+    }
+
+    /**
+     * Retrieve the currently consume character.
+     * @note This performs bounds checking
+     */
+    public function char() {
+        return ($this->char++ < $this->EOF)
+            ? $this->data[$this->char - 1]
+            : false;
+    }
+
+    /**
+     * Get all characters until EOF.
+     * @note This performs bounds checking
+     */
+    public function remainingChars() {
+        if($this->char < $this->EOF) {
+            $data = substr($this->data, $this->char);
+            $this->char = $this->EOF;
+            return $data;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Matches as far as possible until we reach a certain set of bytes
+     * and returns the matched substring.
+     * @param $bytes Bytes to match.
+     */
+    public function charsUntil($bytes, $max = null) {
+        if ($this->char < $this->EOF) {
+            if ($max === 0 || $max) {
+                $len = strcspn($this->data, $bytes, $this->char, $max);
+            } else {
+                $len = strcspn($this->data, $bytes, $this->char);
+            }
+            $string = (string) substr($this->data, $this->char, $len);
+            $this->char += $len;
+            return $string;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Matches as far as possible with a certain set of bytes
+     * and returns the matched substring.
+     * @param $bytes Bytes to match.
+     */
+    public function charsWhile($bytes, $max = null) {
+        if ($this->char < $this->EOF) {
+            if ($max === 0 || $max) {
+                $len = strspn($this->data, $bytes, $this->char, $max);
+            } else {
+                $len = strspn($this->data, $bytes, $this->char);
+            }
+            $string = (string) substr($this->data, $this->char, $len);
+            $this->char += $len;
+            return $string;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Unconsume one character.
+     */
+    public function unget() {
+        if ($this->char <= $this->EOF) {
+            $this->char--;
+        }
+    }
+}
diff --git a/inc/3rdparty/libraries/html5/Parser.php b/inc/3rdparty/libraries/html5/Parser.php
new file mode 100644
index 00000000..5f9ca560
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/Parser.php
@@ -0,0 +1,36 @@
+<?php
+
+require_once dirname(__FILE__) . '/Data.php';
+require_once dirname(__FILE__) . '/InputStream.php';
+require_once dirname(__FILE__) . '/TreeBuilder.php';
+require_once dirname(__FILE__) . '/Tokenizer.php';
+
+/**
+ * Outwards facing interface for HTML5.
+ */
+class HTML5_Parser
+{
+    /**
+     * Parses a full HTML document.
+     * @param $text HTML text to parse
+     * @param $builder Custom builder implementation
+     * @return Parsed HTML as DOMDocument
+     */
+    static public function parse($text, $builder = null) {
+        $tokenizer = new HTML5_Tokenizer($text, $builder);
+        $tokenizer->parse();
+        return $tokenizer->save();
+    }
+    /**
+     * Parses an HTML fragment.
+     * @param $text HTML text to parse
+     * @param $context String name of context element to pretend parsing is in.
+     * @param $builder Custom builder implementation
+     * @return Parsed HTML as DOMDocument
+     */
+    static public function parseFragment($text, $context = null, $builder = null) {
+        $tokenizer = new HTML5_Tokenizer($text, $builder);
+        $tokenizer->parseFragment($context);
+        return $tokenizer->save();
+    }
+}
diff --git a/inc/3rdparty/libraries/html5/Tokenizer.php b/inc/3rdparty/libraries/html5/Tokenizer.php
new file mode 100644
index 00000000..0af07164
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/Tokenizer.php
@@ -0,0 +1,2422 @@
+<?php
+
+/*
+
+Copyright 2007 Jeroen van der Meer <http://jero.net/>
+Copyright 2008 Edward Z. Yang <http://htmlpurifier.org/>
+Copyright 2009 Geoffrey Sneddon <http://gsnedders.com/>
+
+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.
+
+*/
+
+// Some conventions:
+// /* */ indicates verbatim text from the HTML 5 specification
+// // indicates regular comments
+
+// all flags are in hyphenated form
+
+class HTML5_Tokenizer {
+    /**
+     * Points to an InputStream object.
+     */
+    protected $stream;
+
+    /**
+     * Tree builder that the tokenizer emits token to.
+     */
+    private $tree;
+
+    /**
+     * Current content model we are parsing as.
+     */
+    protected $content_model;
+
+    /**
+     * Current token that is being built, but not yet emitted. Also
+     * is the last token emitted, if applicable.
+     */
+    protected $token;
+
+    // These are constants describing the content model
+    const PCDATA    = 0;
+    const RCDATA    = 1;
+    const CDATA     = 2;
+    const PLAINTEXT = 3;
+
+    // These are constants describing tokens
+    // XXX should probably be moved somewhere else, probably the
+    // HTML5 class.
+    const DOCTYPE        = 0;
+    const STARTTAG       = 1;
+    const ENDTAG         = 2;
+    const COMMENT        = 3;
+    const CHARACTER      = 4;
+    const SPACECHARACTER = 5;
+    const EOF            = 6;
+    const PARSEERROR     = 7;
+
+    // These are constants representing bunches of characters.
+    const ALPHA       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    const UPPER_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const LOWER_ALPHA = 'abcdefghijklmnopqrstuvwxyz';
+    const DIGIT       = '0123456789';
+    const HEX         = '0123456789ABCDEFabcdef';
+    const WHITESPACE  = "\t\n\x0c ";
+
+    /**
+     * @param $data Data to parse
+     */
+    public function __construct($data, $builder = null) {
+        $this->stream = new HTML5_InputStream($data);
+        if (!$builder) $this->tree = new HTML5_TreeBuilder;
+        else $this->tree = $builder;
+        $this->content_model = self::PCDATA;
+    }
+
+    public function parseFragment($context = null) {
+        $this->tree->setupContext($context);
+        if ($this->tree->content_model) {
+            $this->content_model = $this->tree->content_model;
+            $this->tree->content_model = null;
+        }
+        $this->parse();
+    }
+
+    // XXX maybe convert this into an iterator? regardless, this function
+    // and the save function should go into a Parser facade of some sort
+    /**
+     * Performs the actual parsing of the document.
+     */
+    public function parse() {
+        // Current state
+        $state = 'data';
+        // This is used to avoid having to have look-behind in the data state.
+        $lastFourChars = '';
+        /**
+         * Escape flag as specified by the HTML5 specification: "used to
+         * control the behavior of the tokeniser. It is either true or
+         * false, and initially must be set to the false state."
+         */
+        $escape = false;
+        //echo "\n\n";
+        while($state !== null) {
+            
+            /*echo $state . ' ';
+            switch ($this->content_model) {
+                case self::PCDATA: echo 'PCDATA'; break;
+                case self::RCDATA: echo 'RCDATA'; break;
+                case self::CDATA: echo 'CDATA'; break;
+                case self::PLAINTEXT: echo 'PLAINTEXT'; break;
+            }
+            if ($escape) echo " escape";
+            echo "\n";*/
+            
+            switch($state) {
+                case 'data':
+
+                    /* Consume the next input character */
+                    $char = $this->stream->char();
+                    $lastFourChars .= $char;
+                    if (strlen($lastFourChars) > 4) $lastFourChars = substr($lastFourChars, -4);
+
+                    // see below for meaning
+                    $hyp_cond = 
+                        !$escape &&
+                        (
+                            $this->content_model === self::RCDATA ||
+                            $this->content_model === self::CDATA
+                        );
+                    $amp_cond =
+                        !$escape &&
+                        (
+                            $this->content_model === self::PCDATA ||
+                            $this->content_model === self::RCDATA
+                        );
+                    $lt_cond =
+                        $this->content_model === self::PCDATA ||
+                        (
+                            (
+                                $this->content_model === self::RCDATA ||
+                                $this->content_model === self::CDATA
+                             ) &&
+                             !$escape
+                        );
+                    $gt_cond = 
+                        $escape &&
+                        (
+                            $this->content_model === self::RCDATA ||
+                            $this->content_model === self::CDATA
+                        );
+
+                    if($char === '&' && $amp_cond) {
+                        /* U+0026 AMPERSAND (&)
+                        When the content model flag is set to one of the PCDATA or RCDATA
+                        states and the escape flag is false: switch to the
+                        character reference data state. Otherwise: treat it as per
+                        the "anything else" entry below. */
+                        $state = 'character reference data';
+
+                    } elseif(
+                        $char === '-' &&
+                        $hyp_cond &&
+                        $lastFourChars === '<!--'
+                    ) {
+                        /*
+                        U+002D HYPHEN-MINUS (-)
+                        If the content model flag is set to either the RCDATA state or
+                        the CDATA state, and the escape flag is false, and there are at
+                        least three characters before this one in the input stream, and the
+                        last four characters in the input stream, including this one, are
+                        U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS,
+                        and U+002D HYPHEN-MINUS ("<!--"), then set the escape flag to true. */
+                        $escape = true;
+
+                        /* In any case, emit the input character as a character token. Stay
+                        in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::CHARACTER,
+                            'data' => '-'
+                        ));
+                        // We do the "any case" part as part of "anything else".
+
+                    /* U+003C LESS-THAN SIGN (<) */
+                    } elseif($char === '<' && $lt_cond) {
+                        /* When the content model flag is set to the PCDATA state: switch
+                        to the tag open state.
+
+                        When the content model flag is set to either the RCDATA state or
+                        the CDATA state and the escape flag is false: switch to the tag
+                        open state.
+
+                        Otherwise: treat it as per the "anything else" entry below. */
+                        $state = 'tag open';
+
+                    /* U+003E GREATER-THAN SIGN (>) */
+                    } elseif(
+                        $char === '>' &&
+                        $gt_cond &&
+                        substr($lastFourChars, 1) === '-->'
+                    ) {
+                        /* If the content model flag is set to either the RCDATA state or
+                        the CDATA state, and the escape flag is true, and the last three
+                        characters in the input stream including this one are U+002D
+                        HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN ("-->"),
+                        set the escape flag to false. */
+                        $escape = false;
+
+                        /* In any case, emit the input character as a character token.
+                        Stay in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::CHARACTER,
+                            'data' => '>'
+                        ));
+                        // We do the "any case" part as part of "anything else".
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Emit an end-of-file token. */
+                        $state = null;
+                        $this->tree->emitToken(array(
+                            'type' => self::EOF
+                        ));
+                    
+                    } elseif($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        // Directly after emitting a token you switch back to the "data
+                        // state". At that point spaceCharacters are important so they are
+                        // emitted separately.
+                        $chars = $this->stream->charsWhile(self::WHITESPACE);
+                        $this->emitToken(array(
+                            'type' => self::SPACECHARACTER,
+                            'data' => $char . $chars
+                        ));
+                        $lastFourChars .= $chars;
+                        if (strlen($lastFourChars) > 4) $lastFourChars = substr($lastFourChars, -4);
+
+                    } else {
+                        /* Anything else
+                        THIS IS AN OPTIMIZATION: Get as many character that
+                        otherwise would also be treated as a character token and emit it
+                        as a single character token. Stay in the data state. */
+                        
+                        $mask = '';
+                        if ($hyp_cond) $mask .= '-';
+                        if ($amp_cond) $mask .= '&';
+                        if ($lt_cond)  $mask .= '<';
+                        if ($gt_cond)  $mask .= '>';
+
+                        if ($mask === '') {
+                            $chars = $this->stream->remainingChars();
+                        } else {
+                            $chars = $this->stream->charsUntil($mask);
+                        }
+
+                        $this->emitToken(array(
+                            'type' => self::CHARACTER,
+                            'data' => $char . $chars
+                        ));
+
+                        $lastFourChars .= $chars;
+                        if (strlen($lastFourChars) > 4) $lastFourChars = substr($lastFourChars, -4);
+
+                        $state = 'data';
+                    }
+                break;
+
+                case 'character reference data':
+                    /* (This cannot happen if the content model flag
+                    is set to the CDATA state.) */
+
+                    /* Attempt to consume a character reference, with no
+                    additional allowed character. */
+                    $entity = $this->consumeCharacterReference();
+
+                    /* If nothing is returned, emit a U+0026 AMPERSAND
+                    character token. Otherwise, emit the character token that
+                    was returned. */
+                    // This is all done when consuming the character reference.
+                    $this->emitToken(array(
+                        'type' => self::CHARACTER,
+                        'data' => $entity
+                    ));
+
+                    /* Finally, switch to the data state. */
+                    $state = 'data';
+                break;
+
+                case 'tag open':
+                    $char = $this->stream->char();
+
+                    switch($this->content_model) {
+                        case self::RCDATA:
+                        case self::CDATA:
+                            /* Consume the next input character. If it is a
+                            U+002F SOLIDUS (/) character, switch to the close
+                            tag open state. Otherwise, emit a U+003C LESS-THAN
+                            SIGN character token and reconsume the current input
+                            character in the data state. */
+                            // We consumed above.
+
+                            if($char === '/') {
+                                $state = 'close tag open';
+
+                            } else {
+                                $this->emitToken(array(
+                                    'type' => self::CHARACTER,
+                                    'data' => '<'
+                                ));
+
+                                $this->stream->unget();
+
+                                $state = 'data';
+                            }
+                        break;
+
+                        case self::PCDATA:
+                            /* If the content model flag is set to the PCDATA state
+                            Consume the next input character: */
+                            // We consumed above.
+
+                            if($char === '!') {
+                                /* U+0021 EXCLAMATION MARK (!)
+                                Switch to the markup declaration open state. */
+                                $state = 'markup declaration open';
+
+                            } elseif($char === '/') {
+                                /* U+002F SOLIDUS (/)
+                                Switch to the close tag open state. */
+                                $state = 'close tag open';
+
+                            } elseif('A' <= $char && $char <= 'Z') {
+                                /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
+                                Create a new start tag token, set its tag name to the lowercase
+                                version of the input character (add 0x0020 to the character's code
+                                point), then switch to the tag name state. (Don't emit the token
+                                yet; further details will be filled in before it is emitted.) */
+                                $this->token = array(
+                                    'name'  => strtolower($char),
+                                    'type'  => self::STARTTAG,
+                                    'attr'  => array()
+                                );
+
+                                $state = 'tag name';
+
+                            } elseif('a' <= $char && $char <= 'z') {
+                                /* U+0061 LATIN SMALL LETTER A through to U+007A LATIN SMALL LETTER Z
+                                Create a new start tag token, set its tag name to the input
+                                character, then switch to the tag name state. (Don't emit
+                                the token yet; further details will be filled in before it
+                                is emitted.) */
+                                $this->token = array(
+                                    'name'  => $char,
+                                    'type'  => self::STARTTAG,
+                                    'attr'  => array()
+                                );
+
+                                $state = 'tag name';
+
+                            } elseif($char === '>') {
+                                /* U+003E GREATER-THAN SIGN (>)
+                                Parse error. Emit a U+003C LESS-THAN SIGN character token and a
+                                U+003E GREATER-THAN SIGN character token. Switch to the data state. */
+                                $this->emitToken(array(
+                                    'type' => self::PARSEERROR,
+                                    'data' => 'expected-tag-name-but-got-right-bracket'
+                                ));
+                                $this->emitToken(array(
+                                    'type' => self::CHARACTER,
+                                    'data' => '<>'
+                                ));
+
+                                $state = 'data';
+
+                            } elseif($char === '?') {
+                                /* U+003F QUESTION MARK (?)
+                                Parse error. Switch to the bogus comment state. */
+                                $this->emitToken(array(
+                                    'type' => self::PARSEERROR,
+                                    'data' => 'expected-tag-name-but-got-question-mark'
+                                ));
+                                $this->token = array(
+                                    'data' => '?',
+                                    'type' => self::COMMENT
+                                );
+                                $state = 'bogus comment';
+
+                            } else {
+                                /* Anything else
+                                Parse error. Emit a U+003C LESS-THAN SIGN character token and
+                                reconsume the current input character in the data state. */
+                                $this->emitToken(array(
+                                    'type' => self::PARSEERROR,
+                                    'data' => 'expected-tag-name'
+                                ));
+                                $this->emitToken(array(
+                                    'type' => self::CHARACTER,
+                                    'data' => '<'
+                                ));
+
+                                $state = 'data';
+                                $this->stream->unget();
+                            }
+                        break;
+                    }
+                break;
+
+                case 'close tag open':
+                    if (
+                        $this->content_model === self::RCDATA ||
+                        $this->content_model === self::CDATA
+                    ) {
+                        /* If the content model flag is set to the RCDATA or CDATA
+                        states... */
+                        $name = strtolower($this->stream->charsWhile(self::ALPHA));
+                        $following = $this->stream->char();
+                        $this->stream->unget();
+                        if (
+                            !$this->token ||
+                            $this->token['name'] !== $name ||
+                            $this->token['name'] === $name && !in_array($following, array("\x09", "\x0A", "\x0C", "\x20", "\x3E", "\x2F", false))
+                        ) {
+                            /* if no start tag token has ever been emitted by this instance
+                            of the tokenizer (fragment case), or, if the next few
+                            characters do not match the tag name of the last start tag
+                            token emitted (compared in an ASCII case-insensitive manner),
+                            or if they do but they are not immediately followed by one of
+                            the following characters:
+
+                                * U+0009 CHARACTER TABULATION
+                                * U+000A LINE FEED (LF)
+                                * U+000C FORM FEED (FF)
+                                * U+0020 SPACE
+                                * U+003E GREATER-THAN SIGN (>)
+                                * U+002F SOLIDUS (/)
+                                * EOF
+
+                            ...then emit a U+003C LESS-THAN SIGN character token, a
+                            U+002F SOLIDUS character token, and switch to the data
+                            state to process the next input character. */
+                            // XXX: Probably ought to replace in_array with $following === x ||...
+
+                            // We also need to emit $name now we've consumed that, as we
+                            // know it'll just be emitted as a character token.
+                            $this->emitToken(array(
+                                'type' => self::CHARACTER,
+                                'data' => '</' . $name
+                            ));
+
+                            $state = 'data';
+                        } else {
+                            // This matches what would happen if we actually did the
+                            // otherwise below (but we can't because we've consumed too
+                            // much).
+
+                            // Start the end tag token with the name we already have.
+                            $this->token = array(
+                                'name'  => $name,
+                                'type'  => self::ENDTAG
+                            );
+
+                            // Change to tag name state.
+                            $state = 'tag name';
+                        }
+                    } elseif ($this->content_model === self::PCDATA) {
+                        /* Otherwise, if the content model flag is set to the PCDATA
+                        state [...]: */
+                        $char = $this->stream->char();
+
+                        if ('A' <= $char && $char <= 'Z') {
+                            /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
+                            Create a new end tag token, set its tag name to the lowercase version
+                            of the input character (add 0x0020 to the character's code point), then
+                            switch to the tag name state. (Don't emit the token yet; further details
+                            will be filled in before it is emitted.) */
+                            $this->token = array(
+                                'name'  => strtolower($char),
+                                'type'  => self::ENDTAG
+                            );
+
+                            $state = 'tag name';
+
+                        } elseif ('a' <= $char && $char <= 'z') {
+                            /* U+0061 LATIN SMALL LETTER A through to U+007A LATIN SMALL LETTER Z
+                            Create a new end tag token, set its tag name to the
+                            input character, then switch to the tag name state.
+                            (Don't emit the token yet; further details will be
+                            filled in before it is emitted.) */
+                            $this->token = array(
+                                'name'  => $char,
+                                'type'  => self::ENDTAG
+                            );
+
+                            $state = 'tag name';
+
+                        } elseif($char === '>') {
+                            /* U+003E GREATER-THAN SIGN (>)
+                            Parse error. Switch to the data state. */
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'expected-closing-tag-but-got-right-bracket'
+                            ));
+                            $state = 'data';
+
+                        } elseif($char === false) {
+                            /* EOF
+                            Parse error. Emit a U+003C LESS-THAN SIGN character token and a U+002F
+                            SOLIDUS character token. Reconsume the EOF character in the data state. */
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'expected-closing-tag-but-got-eof'
+                            ));
+                            $this->emitToken(array(
+                                'type' => self::CHARACTER,
+                                'data' => '</'
+                            ));
+
+                            $this->stream->unget();
+                            $state = 'data';
+
+                        } else {
+                            /* Parse error. Switch to the bogus comment state. */
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'expected-closing-tag-but-got-char'
+                            ));
+                            $this->token = array(
+                                'data' => $char,
+                                'type' => self::COMMENT
+                            );
+                            $state = 'bogus comment';
+                        }
+                    }
+                break;
+
+                case 'tag name':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Switch to the before attribute name state. */
+                        $state = 'before attribute name';
+
+                    } elseif($char === '/') {
+                        /* U+002F SOLIDUS (/)
+                        Switch to the self-closing start tag state. */
+                        $state = 'self-closing start tag';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Append the lowercase version of the current input
+                        character (add 0x0020 to the character's code point) to
+                        the current tag token's tag name. Stay in the tag name state. */
+                        $chars = $this->stream->charsWhile(self::UPPER_ALPHA);
+
+                        $this->token['name'] .= strtolower($char . $chars);
+                        $state = 'tag name';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-tag-name'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current tag token's tag name.
+                        Stay in the tag name state. */
+                        $chars = $this->stream->charsUntil("\t\n\x0C />" . self::UPPER_ALPHA);
+
+                        $this->token['name'] .= $char . $chars;
+                        $state = 'tag name';
+                    }
+                break;
+
+                case 'before attribute name':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    // this conditional is optimized, check bottom
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Stay in the before attribute name state. */
+                        $state = 'before attribute name';
+
+                    } elseif($char === '/') {
+                        /* U+002F SOLIDUS (/)
+                        Switch to the self-closing start tag state. */
+                        $state = 'self-closing start tag';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Start a new attribute in the current tag token. Set that
+                        attribute's name to the lowercase version of the current
+                        input character (add 0x0020 to the character's code
+                        point), and its value to the empty string. Switch to the
+                        attribute name state.*/
+                        $this->token['attr'][] = array(
+                            'name'  => strtolower($char),
+                            'value' => ''
+                        );
+
+                        $state = 'attribute name';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-attribute-name-but-got-eof'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* U+0022 QUOTATION MARK (")
+                           U+0027 APOSTROPHE (')
+                           U+003C LESS-THAN SIGN (<)
+                           U+003D EQUALS SIGN (=)
+                        Parse error. Treat it as per the "anything else" entry
+                        below. */
+                        if($char === '"' || $char === "'" || $char === '<' || $char === '=') {
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'invalid-character-in-attribute-name'
+                            ));
+                        }
+
+                        /* Anything else
+                        Start a new attribute in the current tag token. Set that attribute's
+                        name to the current input character, and its value to the empty string.
+                        Switch to the attribute name state. */
+                        $this->token['attr'][] = array(
+                            'name'  => $char,
+                            'value' => ''
+                        );
+
+                        $state = 'attribute name';
+                    }
+                break;
+
+                case 'attribute name':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    // this conditional is optimized, check bottom
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Switch to the after attribute name state. */
+                        $state = 'after attribute name';
+
+                    } elseif($char === '/') {
+                        /* U+002F SOLIDUS (/)
+                        Switch to the self-closing start tag state. */
+                        $state = 'self-closing start tag';
+
+                    } elseif($char === '=') {
+                        /* U+003D EQUALS SIGN (=)
+                        Switch to the before attribute value state. */
+                        $state = 'before attribute value';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Append the lowercase version of the current input
+                        character (add 0x0020 to the character's code point) to
+                        the current attribute's name. Stay in the attribute name
+                        state. */
+                        $chars = $this->stream->charsWhile(self::UPPER_ALPHA);
+
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['name'] .= strtolower($char . $chars);
+
+                        $state = 'attribute name';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-attribute-name'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* U+0022 QUOTATION MARK (")
+                           U+0027 APOSTROPHE (')
+                           U+003C LESS-THAN SIGN (<)
+                        Parse error. Treat it as per the "anything else"
+                        entry below. */
+                        if($char === '"' || $char === "'" || $char === '<') {
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'invalid-character-in-attribute-name'
+                            ));
+                        }
+
+                        /* Anything else
+                        Append the current input character to the current attribute's name.
+                        Stay in the attribute name state. */
+                        $chars = $this->stream->charsUntil("\t\n\x0C /=>\"'" . self::UPPER_ALPHA);
+
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['name'] .= $char . $chars;
+
+                        $state = 'attribute name';
+                    }
+
+                    /* When the user agent leaves the attribute name state
+                    (and before emitting the tag token, if appropriate), the
+                    complete attribute's name must be compared to the other
+                    attributes on the same token; if there is already an
+                    attribute on the token with the exact same name, then this
+                    is a parse error and the new attribute must be dropped, along
+                    with the value that gets associated with it (if any). */
+                    // this might be implemented in the emitToken method
+                break;
+
+                case 'after attribute name':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    // this is an optimized conditional, check the bottom
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Stay in the after attribute name state. */
+                        $state = 'after attribute name';
+
+                    } elseif($char === '/') {
+                        /* U+002F SOLIDUS (/)
+                        Switch to the self-closing start tag state. */
+                        $state = 'self-closing start tag';
+
+                    } elseif($char === '=') {
+                        /* U+003D EQUALS SIGN (=)
+                        Switch to the before attribute value state. */
+                        $state = 'before attribute value';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Start a new attribute in the current tag token. Set that
+                        attribute's name to the lowercase version of the current
+                        input character (add 0x0020 to the character's code
+                        point), and its value to the empty string. Switch to the
+                        attribute name state. */
+                        $this->token['attr'][] = array(
+                            'name'  => strtolower($char),
+                            'value' => ''
+                        );
+
+                        $state = 'attribute name';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-end-of-tag-but-got-eof'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* U+0022 QUOTATION MARK (")
+                           U+0027 APOSTROPHE (')
+                           U+003C LESS-THAN SIGN(<)
+                        Parse error. Treat it as per the "anything else"
+                        entry below. */
+                        if($char === '"' || $char === "'" || $char === "<") {
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'invalid-character-after-attribute-name'
+                            ));
+                        }
+
+                        /* Anything else
+                        Start a new attribute in the current tag token. Set that attribute's
+                        name to the current input character, and its value to the empty string.
+                        Switch to the attribute name state. */
+                        $this->token['attr'][] = array(
+                            'name'  => $char,
+                            'value' => ''
+                        );
+
+                        $state = 'attribute name';
+                    }
+                break;
+
+                case 'before attribute value':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    // this is an optimized conditional
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Stay in the before attribute value state. */
+                        $state = 'before attribute value';
+
+                    } elseif($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Switch to the attribute value (double-quoted) state. */
+                        $state = 'attribute value (double-quoted)';
+
+                    } elseif($char === '&') {
+                        /* U+0026 AMPERSAND (&)
+                        Switch to the attribute value (unquoted) state and reconsume
+                        this input character. */
+                        $this->stream->unget();
+                        $state = 'attribute value (unquoted)';
+
+                    } elseif($char === '\'') {
+                        /* U+0027 APOSTROPHE (')
+                        Switch to the attribute value (single-quoted) state. */
+                        $state = 'attribute value (single-quoted)';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Emit the current tag token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-attribute-value-but-got-right-bracket'
+                        ));
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-attribute-value-but-got-eof'
+                        ));
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* U+003D EQUALS SIGN (=)
+                         * U+003C LESS-THAN SIGN (<)
+                        Parse error. Treat it as per the "anything else" entry below. */
+                        if($char === '=' || $char === '<') {
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'equals-in-unquoted-attribute-value'
+                            ));
+                        }
+
+                        /* Anything else
+                        Append the current input character to the current attribute's value.
+                        Switch to the attribute value (unquoted) state. */
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['value'] .= $char;
+
+                        $state = 'attribute value (unquoted)';
+                    }
+                break;
+
+                case 'attribute value (double-quoted)':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    if($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Switch to the after attribute value (quoted) state. */
+                        $state = 'after attribute value (quoted)';
+
+                    } elseif($char === '&') {
+                        /* U+0026 AMPERSAND (&)
+                        Switch to the character reference in attribute value
+                        state, with the additional allowed character
+                        being U+0022 QUOTATION MARK ("). */
+                        $this->characterReferenceInAttributeValue('"');
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-attribute-value-double-quote'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current attribute's value.
+                        Stay in the attribute value (double-quoted) state. */
+                        $chars = $this->stream->charsUntil('"&');
+
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['value'] .= $char . $chars;
+
+                        $state = 'attribute value (double-quoted)';
+                    }
+                break;
+
+                case 'attribute value (single-quoted)':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    if($char === "'") {
+                        /* U+0022 QUOTATION MARK (')
+                        Switch to the after attribute value state. */
+                        $state = 'after attribute value (quoted)';
+
+                    } elseif($char === '&') {
+                        /* U+0026 AMPERSAND (&)
+                        Switch to the entity in attribute value state. */
+                        $this->characterReferenceInAttributeValue("'");
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-attribute-value-single-quote'
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current attribute's value.
+                        Stay in the attribute value (single-quoted) state. */
+                        $chars = $this->stream->charsUntil("'&");
+
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['value'] .= $char . $chars;
+
+                        $state = 'attribute value (single-quoted)';
+                    }
+                break;
+
+                case 'attribute value (unquoted)':
+                    // Consume the next input character:
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                        U+000A LINE FEED (LF)
+                        U+000C FORM FEED (FF)
+                        U+0020 SPACE
+                        Switch to the before attribute name state. */
+                        $state = 'before attribute name';
+
+                    } elseif($char === '&') {
+                        /* U+0026 AMPERSAND (&)
+                        Switch to the entity in attribute value state, with the 
+                        additional allowed character  being U+003E 
+                        GREATER-THAN SIGN (>). */
+                        $this->characterReferenceInAttributeValue('>');
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-attribute-value-no-quotes'
+                        ));
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* U+0022 QUOTATION MARK (")
+                           U+0027 APOSTROPHE (')
+                           U+003C LESS-THAN SIGN (<)
+                           U+003D EQUALS SIGN (=)
+                        Parse error. Treat it as per the "anything else"
+                        entry below. */
+                        if($char === '"' || $char === "'" || $char === '=' || $char == '<') {
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'unexpected-character-in-unquoted-attribute-value'
+                            ));
+                        }
+
+                        /* Anything else
+                        Append the current input character to the current attribute's value.
+                        Stay in the attribute value (unquoted) state. */
+                        $chars = $this->stream->charsUntil("\t\n\x0c &>\"'=");
+
+                        $last = count($this->token['attr']) - 1;
+                        $this->token['attr'][$last]['value'] .= $char . $chars;
+
+                        $state = 'attribute value (unquoted)';
+                    }
+                break;
+
+                case 'after attribute value (quoted)':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Switch to the before attribute name state. */
+                        $state = 'before attribute name';
+
+                    } elseif ($char === '/') {
+                        /* U+002F SOLIDUS (/)
+                        Switch to the self-closing start tag state. */
+                        $state = 'self-closing start tag';
+
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current tag token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-EOF-after-attribute-value'
+                        ));
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Parse error. Reconsume the character in the before attribute
+                        name state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-character-after-attribute-value'
+                        ));
+                        $this->stream->unget();
+                        $state = 'before attribute name';
+                    }
+                break;
+
+                case 'self-closing start tag':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Set the self-closing flag of the current tag token.
+                        Emit the current tag token. Switch to the data state. */
+                        // not sure if this is the name we want
+                        $this->token['self-closing'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Reconsume the EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-eof-after-self-closing'
+                        ));
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Parse error. Reconsume the character in the before attribute name state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-character-after-self-closing'
+                        ));
+                        $this->stream->unget();
+                        $state = 'before attribute name';
+                    }
+                break;
+
+                case 'bogus comment':
+                    /* (This can only happen if the content model flag is set to the PCDATA state.) */
+                    /* Consume every character up to the first U+003E GREATER-THAN SIGN
+                    character (>) or the end of the file (EOF), whichever comes first. Emit
+                    a comment token whose data is the concatenation of all the characters
+                    starting from and including the character that caused the state machine
+                    to switch into the bogus comment state, up to and including the last
+                    consumed character before the U+003E character, if any, or up to the
+                    end of the file otherwise. (If the comment was started by the end of
+                    the file (EOF), the token is empty.) */
+                    $this->token['data'] .= (string) $this->stream->charsUntil('>');
+                    $this->stream->char();
+
+                    $this->emitToken($this->token);
+
+                    /* Switch to the data state. */
+                    $state = 'data';
+                break;
+
+                case 'markup declaration open':
+                    // Consume for below
+                    $hyphens = $this->stream->charsWhile('-', 2);
+                    if ($hyphens === '-') {
+                        $this->stream->unget();
+                    }
+                    if ($hyphens !== '--') {
+                        $alpha = $this->stream->charsWhile(self::ALPHA, 7);
+                    }
+
+                    /* If the next two characters are both U+002D HYPHEN-MINUS (-)
+                    characters, consume those two characters, create a comment token whose
+                    data is the empty string, and switch to the comment state. */
+                    if($hyphens === '--') {
+                        $state = 'comment start';
+                        $this->token = array(
+                            'data' => '',
+                            'type' => self::COMMENT
+                        );
+
+                    /* Otherwise if the next seven characters are a case-insensitive match
+                    for the word "DOCTYPE", then consume those characters and switch to the
+                    DOCTYPE state. */
+                    } elseif(strtoupper($alpha) === 'DOCTYPE') {
+                        $state = 'DOCTYPE';
+
+                    // XXX not implemented
+                    /* Otherwise, if the insertion mode is "in foreign content"
+                    and the current node is not an element in the HTML namespace
+                    and the next seven characters are an ASCII case-sensitive
+                    match for the string "[CDATA[" (the five uppercase letters
+                    "CDATA" with a U+005B LEFT SQUARE BRACKET character before
+                    and after), then consume those characters and switch to the
+                    CDATA section state (which is unrelated to the content model
+                    flag's CDATA state). */
+
+                    /* Otherwise, is is a parse error. Switch to the bogus comment state.
+                    The next character that is consumed, if any, is the first character
+                    that will be in the comment. */
+                    } else {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-dashes-or-doctype'
+                        ));
+                        $this->token = array(
+                            'data' => (string) $alpha,
+                            'type' => self::COMMENT
+                        );
+                        $state = 'bogus comment';
+                    }
+                break;
+
+                case 'comment start':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === '-') {
+                        /* U+002D HYPHEN-MINUS (-)
+                        Switch to the comment start dash state. */
+                        $state = 'comment start dash';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Emit the comment token. Switch to the
+                        data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'incorrect-comment'
+                        ));
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Emit the comment token. Reconsume the
+                        EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Append the input character to the comment token's
+                        data. Switch to the comment state. */
+                        $this->token['data'] .= $char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'comment start dash':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+                    if ($char === '-') {
+                        /* U+002D HYPHEN-MINUS (-)
+                        Switch to the comment end state */
+                        $state = 'comment end';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Emit the comment token. Switch to the
+                        data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'incorrect-comment'
+                        ));
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* Parse error. Emit the comment token. Reconsume the
+                        EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        $this->token['data'] .= '-' . $char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'comment':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === '-') {
+                        /* U+002D HYPHEN-MINUS (-)
+                        Switch to the comment end dash state */
+                        $state = 'comment end dash';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Emit the comment token. Reconsume the EOF character
+                        in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append the input character to the comment token's data. Stay in
+                        the comment state. */
+                        $chars = $this->stream->charsUntil('-');
+
+                        $this->token['data'] .= $char . $chars;
+                    }
+                break;
+
+                case 'comment end dash':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === '-') {
+                        /* U+002D HYPHEN-MINUS (-)
+                        Switch to the comment end state  */
+                        $state = 'comment end';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Emit the comment token. Reconsume the EOF character
+                        in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment-end-dash'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append a U+002D HYPHEN-MINUS (-) character and the input
+                        character to the comment token's data. Switch to the comment state. */
+                        $this->token['data'] .= '-'.$char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'comment end':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the comment token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif($char === '-') {
+                        /* U+002D HYPHEN-MINUS (-)
+                        Parse error. Append a U+002D HYPHEN-MINUS (-) character
+                        to the comment token's data. Stay in the comment end
+                        state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-dash-after-double-dash-in-comment'
+                        ));
+                        $this->token['data'] .= '-';
+
+                    } elseif($char === "\t" || $char === "\n" || $char === "\x0a" || $char === ' ') {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-space-after-double-dash-in-comment'
+                        ));
+                        $this->token['data'] .= '--' . $char;
+                        $state = 'comment end space';
+
+                    } elseif($char === '!') {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-bang-after-double-dash-in-comment'
+                        ));
+                        $state = 'comment end bang';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Emit the comment token. Reconsume the
+                        EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment-double-dash'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Parse error. Append two U+002D HYPHEN-MINUS (-)
+                        characters and the input character to the comment token's
+                        data. Switch to the comment state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-comment'
+                        ));
+                        $this->token['data'] .= '--'.$char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'comment end bang':
+                    $char = $this->stream->char();
+                    if ($char === '>') {
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === "-") {
+                        $this->token['data'] .= '--!';
+                        $state = 'comment end dash';
+                    } elseif ($char === false) {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-comment-end-bang'
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        $this->token['data'] .= '--!' . $char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'comment end space':
+                    $char = $this->stream->char();
+                    if ($char === '>') {
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === '-') {
+                        $state = 'comment end dash';
+                    } elseif ($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        $this->token['data'] .= $char;
+                    } elseif ($char === false) {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-eof-in-comment-end-space',
+                        ));
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        $this->token['data'] .= $char;
+                        $state = 'comment';
+                    }
+                break;
+
+                case 'DOCTYPE':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Switch to the before DOCTYPE name state. */
+                        $state = 'before DOCTYPE name';
+                    
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Create a new DOCTYPE token. Set its
+                        force-quirks flag to on. Emit the token. Reconsume the
+                        EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'need-space-after-doctype-but-got-eof'
+                        ));
+                        $this->emitToken(array(
+                            'name' => '',
+                            'type' => self::DOCTYPE,
+                            'force-quirks' => true,
+                            'error' => true
+                        ));
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Parse error. Reconsume the current character in the
+                        before DOCTYPE name state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'need-space-after-doctype'
+                        ));
+                        $this->stream->unget();
+                        $state = 'before DOCTYPE name';
+                    }
+                break;
+
+                case 'before DOCTYPE name':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the before DOCTYPE name state. */
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Create a new DOCTYPE token. Set its
+                        force-quirks flag to on. Emit the token. Switch to the
+                        data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-doctype-name-but-got-right-bracket'
+                        ));
+                        $this->emitToken(array(
+                            'name' => '',
+                            'type' => self::DOCTYPE,
+                            'force-quirks' => true,
+                            'error' => true
+                        ));
+
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Create a new DOCTYPE token. Set the token's name to the
+                        lowercase version of the input character (add 0x0020 to
+                        the character's code point). Switch to the DOCTYPE name
+                        state. */
+                        $this->token = array(
+                            'name' => strtolower($char),
+                            'type' => self::DOCTYPE,
+                            'error' => true
+                        );
+
+                        $state = 'DOCTYPE name';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Create a new DOCTYPE token. Set its
+                        force-quirks flag to on. Emit the token. Reconsume the
+                        EOF character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'expected-doctype-name-but-got-eof'
+                        ));
+                        $this->emitToken(array(
+                            'name' => '',
+                            'type' => self::DOCTYPE,
+                            'force-quirks' => true,
+                            'error' => true
+                        ));
+
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Create a new DOCTYPE token. Set the token's name to the
+                        current input character. Switch to the DOCTYPE name state. */
+                        $this->token = array(
+                            'name' => $char,
+                            'type' => self::DOCTYPE,
+                            'error' => true
+                        );
+
+                        $state = 'DOCTYPE name';
+                    }
+                break;
+
+                case 'DOCTYPE name':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Switch to the after DOCTYPE name state. */
+                        $state = 'after DOCTYPE name';
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current DOCTYPE token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif('A' <= $char && $char <= 'Z') {
+                        /* U+0041 LATIN CAPITAL LETTER A through to U+005A LATIN CAPITAL LETTER Z
+                        Append the lowercase version of the input character
+                        (add 0x0020 to the character's code point) to the current
+                        DOCTYPE token's name. Stay in the DOCTYPE name state. */
+                        $this->token['name'] .= strtolower($char);
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype-name'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current
+                        DOCTYPE token's name. Stay in the DOCTYPE name state. */
+                        $this->token['name'] .= $char;
+                    }
+
+                    // XXX this is probably some sort of quirks mode designation,
+                    // check tree-builder to be sure. In general 'error' needs
+                    // to be specc'ified, this probably means removing it at the end
+                    $this->token['error'] = ($this->token['name'] === 'HTML')
+                        ? false
+                        : true;
+                break;
+
+                case 'after DOCTYPE name':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the after DOCTYPE name state. */
+
+                    } elseif($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current DOCTYPE token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else */
+
+                        $nextSix = strtoupper($char . $this->stream->charsWhile(self::ALPHA, 5));
+                        if ($nextSix === 'PUBLIC') {
+                            /* If the next six characters are an ASCII
+                            case-insensitive match for the word "PUBLIC", then
+                            consume those characters and switch to the before
+                            DOCTYPE public identifier state. */
+                            $state = 'before DOCTYPE public identifier';
+
+                        } elseif ($nextSix === 'SYSTEM') {
+                            /* Otherwise, if the next six characters are an ASCII
+                            case-insensitive match for the word "SYSTEM", then
+                            consume those characters and switch to the before
+                            DOCTYPE system identifier state. */
+                            $state = 'before DOCTYPE system identifier';
+
+                        } else {
+                            /* Otherwise, this is the parse error. Set the DOCTYPE
+                            token's force-quirks flag to on. Switch to the bogus
+                            DOCTYPE state. */
+                            $this->emitToken(array(
+                                'type' => self::PARSEERROR,
+                                'data' => 'expected-space-or-right-bracket-in-doctype'
+                            ));
+                            $this->token['force-quirks'] = true;
+                            $this->token['error'] = true;
+                            $state = 'bogus DOCTYPE';
+                        }
+                    }
+                break;
+
+                case 'before DOCTYPE public identifier':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the before DOCTYPE public identifier state. */
+                    } elseif ($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Set the DOCTYPE token's public identifier to the empty
+                        string (not missing), then switch to the DOCTYPE public
+                        identifier (double-quoted) state. */
+                        $this->token['public'] = '';
+                        $state = 'DOCTYPE public identifier (double-quoted)';
+                    } elseif ($char === "'") {
+                        /* U+0027 APOSTROPHE (')
+                        Set the DOCTYPE token's public identifier to the empty
+                        string (not missing), then switch to the DOCTYPE public
+                        identifier (single-quoted) state. */
+                        $this->token['public'] = '';
+                        $state = 'DOCTYPE public identifier (single-quoted)';
+                    } elseif ($char === '>') {
+                        /* Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-end-of-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* Parse error. Set the DOCTYPE token's force-quirks
+                        flag to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Switch to the bogus DOCTYPE state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $state = 'bogus DOCTYPE';
+                    }
+                break;
+
+                case 'DOCTYPE public identifier (double-quoted)':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Switch to the after DOCTYPE public identifier state. */
+                        $state = 'after DOCTYPE public identifier';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-end-of-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current
+                        DOCTYPE token's public identifier. Stay in the DOCTYPE
+                        public identifier (double-quoted) state. */
+                        $this->token['public'] .= $char;
+                    }
+                break;
+
+                case 'DOCTYPE public identifier (single-quoted)':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === "'") {
+                        /* U+0027 APOSTROPHE (')
+                        Switch to the after DOCTYPE public identifier state. */
+                        $state = 'after DOCTYPE public identifier';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-end-of-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current
+                        DOCTYPE token's public identifier. Stay in the DOCTYPE
+                        public identifier (double-quoted) state. */
+                        $this->token['public'] .= $char;
+                    }
+                break;
+
+                case 'after DOCTYPE public identifier':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the after DOCTYPE public identifier state. */
+                    } elseif ($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Set the DOCTYPE token's system identifier to the
+                        empty string (not missing), then switch to the DOCTYPE
+                        system identifier (double-quoted) state. */
+                        $this->token['system'] = '';
+                        $state = 'DOCTYPE system identifier (double-quoted)';
+                    } elseif ($char === "'") {
+                        /* U+0027 APOSTROPHE (')
+                        Set the DOCTYPE token's system identifier to the
+                        empty string (not missing), then switch to the DOCTYPE
+                        system identifier (single-quoted) state. */
+                        $this->token['system'] = '';
+                        $state = 'DOCTYPE system identifier (single-quoted)';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current DOCTYPE token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* Parse error. Set the DOCTYPE token's force-quirks
+                        flag to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Switch to the bogus DOCTYPE state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $state = 'bogus DOCTYPE';
+                    }
+                break;
+
+                case 'before DOCTYPE system identifier':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the before DOCTYPE system identifier state. */
+                    } elseif ($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Set the DOCTYPE token's system identifier to the empty
+                        string (not missing), then switch to the DOCTYPE system
+                        identifier (double-quoted) state. */
+                        $this->token['system'] = '';
+                        $state = 'DOCTYPE system identifier (double-quoted)';
+                    } elseif ($char === "'") {
+                        /* U+0027 APOSTROPHE (')
+                        Set the DOCTYPE token's system identifier to the empty
+                        string (not missing), then switch to the DOCTYPE system
+                        identifier (single-quoted) state. */
+                        $this->token['system'] = '';
+                        $state = 'DOCTYPE system identifier (single-quoted)';
+                    } elseif ($char === '>') {
+                        /* Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* Parse error. Set the DOCTYPE token's force-quirks
+                        flag to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Switch to the bogus DOCTYPE state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $state = 'bogus DOCTYPE';
+                    }
+                break;
+
+                case 'DOCTYPE system identifier (double-quoted)':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === '"') {
+                        /* U+0022 QUOTATION MARK (")
+                        Switch to the after DOCTYPE system identifier state. */
+                        $state = 'after DOCTYPE system identifier';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-end-of-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current
+                        DOCTYPE token's system identifier. Stay in the DOCTYPE
+                        system identifier (double-quoted) state. */
+                        $this->token['system'] .= $char;
+                    }
+                break;
+
+                case 'DOCTYPE system identifier (single-quoted)':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === "'") {
+                        /* U+0027 APOSTROPHE (')
+                        Switch to the after DOCTYPE system identifier state. */
+                        $state = 'after DOCTYPE system identifier';
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Switch to the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-end-of-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* EOF
+                        Parse error. Set the DOCTYPE token's force-quirks flag
+                        to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Append the current input character to the current
+                        DOCTYPE token's system identifier. Stay in the DOCTYPE
+                        system identifier (double-quoted) state. */
+                        $this->token['system'] .= $char;
+                    }
+                break;
+
+                case 'after DOCTYPE system identifier':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if($char === "\t" || $char === "\n" || $char === "\x0c" || $char === ' ') {
+                        /* U+0009 CHARACTER TABULATION
+                           U+000A LINE FEED (LF)
+                           U+000C FORM FEED (FF)
+                           U+0020 SPACE
+                        Stay in the after DOCTYPE system identifier state. */
+                    } elseif ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the current DOCTYPE token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+                    } elseif ($char === false) {
+                        /* Parse error. Set the DOCTYPE token's force-quirks
+                        flag to on. Emit that DOCTYPE token. Reconsume the EOF
+                        character in the data state. */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'eof-in-doctype'
+                        ));
+                        $this->token['force-quirks'] = true;
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+                    } else {
+                        /* Anything else
+                        Parse error. Switch to the bogus DOCTYPE state.
+                        (This does not set the DOCTYPE token's force-quirks
+                        flag to on.) */
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'unexpected-char-in-doctype'
+                        ));
+                        $state = 'bogus DOCTYPE';
+                    }
+                break;
+
+                case 'bogus DOCTYPE':
+                    /* Consume the next input character: */
+                    $char = $this->stream->char();
+
+                    if ($char === '>') {
+                        /* U+003E GREATER-THAN SIGN (>)
+                        Emit the DOCTYPE token. Switch to the data state. */
+                        $this->emitToken($this->token);
+                        $state = 'data';
+
+                    } elseif($char === false) {
+                        /* EOF
+                        Emit the DOCTYPE token. Reconsume the EOF character in
+                        the data state. */
+                        $this->emitToken($this->token);
+                        $this->stream->unget();
+                        $state = 'data';
+
+                    } else {
+                        /* Anything else
+                        Stay in the bogus DOCTYPE state. */
+                    }
+                break;
+
+                // case 'cdataSection':
+
+            }
+        }
+    }
+
+    /**
+     * Returns a serialized representation of the tree.
+     */
+    public function save() {
+        return $this->tree->save();
+    }
+
+    /**
+     * Returns the input stream.
+     */
+    public function stream() {
+        return $this->stream;
+    }
+
+    private function consumeCharacterReference($allowed = false, $inattr = false) {
+        // This goes quite far against spec, and is far closer to the Python
+        // impl., mainly because we don't do the large unconsuming the spec
+        // requires.
+
+        // All consumed characters.
+        $chars = $this->stream->char();
+
+        /* This section defines how to consume a character
+        reference. This definition is used when parsing character
+        references in text and in attributes.
+
+        The behavior depends on the identity of the next character
+        (the one immediately after the U+0026 AMPERSAND character): */
+
+        if (
+            $chars[0] === "\x09" ||
+            $chars[0] === "\x0A" ||
+            $chars[0] === "\x0C" ||
+            $chars[0] === "\x20" ||
+            $chars[0] === '<' ||
+            $chars[0] === '&' ||
+            $chars === false ||
+            $chars[0] === $allowed
+        ) {
+            /* U+0009 CHARACTER TABULATION
+               U+000A LINE FEED (LF)
+               U+000C FORM FEED (FF)
+               U+0020 SPACE
+               U+003C LESS-THAN SIGN
+               U+0026 AMPERSAND
+               EOF
+               The additional allowed character, if there is one
+            Not a character reference. No characters are consumed,
+            and nothing is returned. (This is not an error, either.) */
+            // We already consumed, so unconsume.
+            $this->stream->unget();
+            return '&';
+        } elseif ($chars[0] === '#') {
+            /* Consume the U+0023 NUMBER SIGN. */
+            // Um, yeah, we already did that.
+            /* The behavior further depends on the character after
+            the U+0023 NUMBER SIGN: */
+            $chars .= $this->stream->char();
+            if (isset($chars[1]) && ($chars[1] === 'x' || $chars[1] === 'X')) {
+                /* U+0078 LATIN SMALL LETTER X
+                   U+0058 LATIN CAPITAL LETTER X */
+                /* Consume the X. */
+                // Um, yeah, we already did that.
+                /* Follow the steps below, but using the range of
+                characters U+0030 DIGIT ZERO through to U+0039 DIGIT
+                NINE, U+0061 LATIN SMALL LETTER A through to U+0066
+                LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER
+                A, through to U+0046 LATIN CAPITAL LETTER F (in other
+                words, 0123456789, ABCDEF, abcdef). */
+                $char_class = self::HEX;
+                /* When it comes to interpreting the
+                number, interpret it as a hexadecimal number. */
+                $hex = true;
+            } else {
+                /* Anything else */
+                // Unconsume because we shouldn't have consumed this.
+                $chars = $chars[0];
+                $this->stream->unget();
+                /* Follow the steps below, but using the range of
+                characters U+0030 DIGIT ZERO through to U+0039 DIGIT
+                NINE (i.e. just 0123456789). */
+                $char_class = self::DIGIT;
+                /* When it comes to interpreting the number,
+                interpret it as a decimal number. */
+                $hex = false;
+            }
+
+            /* Consume as many characters as match the range of characters given above. */
+            $consumed = $this->stream->charsWhile($char_class);
+            if ($consumed === '' || $consumed === false) {
+                /* If no characters match the range, then don't consume
+                any characters (and unconsume the U+0023 NUMBER SIGN
+                character and, if appropriate, the X character). This
+                is a parse error; nothing is returned. */
+                $this->emitToken(array(
+                    'type' => self::PARSEERROR,
+                    'data' => 'expected-numeric-entity'
+                ));
+                return '&' . $chars;
+            } else {
+                /* Otherwise, if the next character is a U+003B SEMICOLON,
+                consume that too. If it isn't, there is a parse error. */
+                if ($this->stream->char() !== ';') {
+                    $this->stream->unget();
+                    $this->emitToken(array(
+                        'type' => self::PARSEERROR,
+                        'data' => 'numeric-entity-without-semicolon'
+                    ));
+                }
+
+                /* If one or more characters match the range, then take
+                them all and interpret the string of characters as a number
+                (either hexadecimal or decimal as appropriate). */
+                $codepoint = $hex ? hexdec($consumed) : (int) $consumed;
+
+                /* If that number is one of the numbers in the first column
+                of the following table, then this is a parse error. Find the
+                row with that number in the first column, and return a
+                character token for the Unicode character given in the
+                second column of that row. */
+                $new_codepoint = HTML5_Data::getRealCodepoint($codepoint);
+                if ($new_codepoint) {
+                    $this->emitToken(array(
+                        'type' => self::PARSEERROR,
+                        'data' => 'illegal-windows-1252-entity'
+                    ));
+                    return HTML5_Data::utf8chr($new_codepoint);
+                } else {
+                    /* Otherwise, if the number is greater than 0x10FFFF, then 
+                     * this is a parse error. Return a U+FFFD REPLACEMENT 
+                     * CHARACTER. */
+                    if ($codepoint > 0x10FFFF) {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'overlong-character-entity' // XXX probably not correct
+                        ));
+                        return "\xEF\xBF\xBD";
+                    }
+                    /* Otherwise, return a character token for the Unicode 
+                     * character whose code point is that number.  If the 
+                     * number is in the range 0x0001 to 0x0008,    0x000E to 
+                     * 0x001F,  0x007F  to 0x009F, 0xD800 to 0xDFFF, 0xFDD0 to 
+                     * 0xFDEF, or is one of 0x000B, 0xFFFE, 0xFFFF, 0x1FFFE, 
+                     * 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE, 
+                     * 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE, 
+                     * 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 
+                     * 0xAFFFF, 0xBFFFE, 0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE, 
+                     * 0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, 
+                     * or 0x10FFFF, then this is a parse error. */
+                    // && has higher precedence than ||
+                    if (
+                        $codepoint >= 0x0000 && $codepoint <= 0x0008 ||
+                        $codepoint === 0x000B ||
+                        $codepoint >= 0x000E && $codepoint <= 0x001F ||
+                        $codepoint >= 0x007F && $codepoint <= 0x009F ||
+                        $codepoint >= 0xD800 && $codepoint <= 0xDFFF ||
+                        $codepoint >= 0xFDD0 && $codepoint <= 0xFDEF ||
+                        ($codepoint & 0xFFFE) === 0xFFFE ||
+                        $codepoint == 0x10FFFF || $codepoint == 0x10FFFE
+                    ) {
+                        $this->emitToken(array(
+                            'type' => self::PARSEERROR,
+                            'data' => 'illegal-codepoint-for-numeric-entity'
+                        ));
+                    }
+                    return HTML5_Data::utf8chr($codepoint);
+                }
+            }
+
+        } else {
+            /* Anything else */
+
+            /* Consume the maximum number of characters possible,
+            with the consumed characters matching one of the
+            identifiers in the first column of the named character
+            references table (in a case-sensitive manner). */
+            // What we actually do here is consume as much as we can while it
+            // matches the start of one of the identifiers in the first column.
+
+            $refs = HTML5_Data::getNamedCharacterReferences();
+            
+            // Get the longest string which is the start of an identifier
+            // ($chars) as well as the longest identifier which matches ($id)
+            // and its codepoint ($codepoint).
+            $codepoint = false;
+            $char = $chars;
+            while ($char !== false && isset($refs[$char])) {
+                $refs = $refs[$char];
+                if (isset($refs['codepoint'])) {
+                    $id = $chars;
+                    $codepoint = $refs['codepoint'];
+                }
+                $chars .= $char = $this->stream->char();
+            }
+            
+            // Unconsume the one character we just took which caused the while
+            // statement to fail. This could be anything and could cause state
+            // changes (as if it matches the while loop it must be
+            // alphanumeric so we can just concat it to whatever we get later).
+            $this->stream->unget();
+            if ($char !== false) {
+                $chars = substr($chars, 0, -1);
+            }
+
+            /* If no match can be made, then this is a parse error.
+            No characters are consumed, and nothing is returned. */
+            if (!$codepoint) {
+                $this->emitToken(array(
+                    'type' => self::PARSEERROR,
+                    'data' => 'expected-named-entity'
+                ));
+                return '&' . $chars;
+            }
+
+            /* If the last character matched is not a U+003B SEMICOLON
+            (;), there is a parse error. */
+            $semicolon = true;
+            if (substr($id, -1) !== ';') {
+                $this->emitToken(array(
+                    'type' => self::PARSEERROR,
+                    'data' => 'named-entity-without-semicolon'
+                ));
+                $semicolon = false;
+            }
+
+            /* If the character reference is being consumed as part of
+            an attribute, and the last character matched is not a
+            U+003B SEMICOLON (;), and the next character is in the
+            range U+0030 DIGIT ZERO to U+0039 DIGIT NINE, U+0041
+            LATIN CAPITAL LETTER A to U+005A LATIN CAPITAL LETTER Z,
+            or U+0061 LATIN SMALL LETTER A to U+007A LATIN SMALL LETTER Z,
+            then, for historical reasons, all the characters that were
+            matched after the U+0026 AMPERSAND (&) must be unconsumed,
+            and nothing is returned. */
+            if ($inattr && !$semicolon) {
+                // The next character is either the next character in $chars or in the stream.
+                if (strlen($chars) > strlen($id)) {
+                    $next = substr($chars, strlen($id), 1);
+                } else {
+                    $next = $this->stream->char();
+                    $this->stream->unget();
+                }
+                if (
+                    '0' <= $next && $next <= '9' ||
+                    'A' <= $next && $next <= 'Z' ||
+                    'a' <= $next && $next <= 'z'
+                ) {
+                    return '&' . $chars;
+                }
+            }
+
+            /* Otherwise, return a character token for the character
+            corresponding to the character reference name (as given
+            by the second column of the named character references table). */
+            return HTML5_Data::utf8chr($codepoint) . substr($chars, strlen($id));
+        }
+    }
+
+    private function characterReferenceInAttributeValue($allowed = false) {
+        /* Attempt to consume a character reference. */
+        $entity = $this->consumeCharacterReference($allowed, true);
+
+        /* If nothing is returned, append a U+0026 AMPERSAND
+        character to the current attribute's value.
+
+        Otherwise, append the returned character token to the
+        current attribute's value. */
+        $char = (!$entity)
+            ? '&'
+            : $entity;
+
+        $last = count($this->token['attr']) - 1;
+        $this->token['attr'][$last]['value'] .= $char;
+
+        /* Finally, switch back to the attribute value state that you
+        were in when were switched into this state. */
+    }
+
+    /**
+     * Emits a token, passing it on to the tree builder.
+     */
+    protected function emitToken($token, $checkStream = true, $dry = false) {
+        if ($checkStream) {
+            // Emit errors from input stream.
+            while ($this->stream->errors) {
+                $this->emitToken(array_shift($this->stream->errors), false);
+            }
+        }
+        if($token['type'] === self::ENDTAG && !empty($token['attr'])) {
+            for ($i = 0; $i < count($token['attr']); $i++) {
+                $this->emitToken(array(
+                    'type' => self::PARSEERROR,
+                    'data' => 'attributes-in-end-tag'
+                ));
+            }
+        }
+        if($token['type'] === self::ENDTAG && !empty($token['self-closing'])) {
+            $this->emitToken(array(
+                'type' => self::PARSEERROR,
+                'data' => 'self-closing-flag-on-end-tag',
+            ));
+        }
+        if($token['type'] === self::STARTTAG) {
+            // This could be changed to actually pass the tree-builder a hash
+            $hash = array();
+            foreach ($token['attr'] as $keypair) {
+                if (isset($hash[$keypair['name']])) {
+                    $this->emitToken(array(
+                        'type' => self::PARSEERROR,
+                        'data' => 'duplicate-attribute',
+                    ));
+                } else {
+                    $hash[$keypair['name']] = $keypair['value'];
+                }
+            }
+        }
+
+        if(!$dry) {
+            // the current structure of attributes is not a terribly good one
+            $this->tree->emitToken($token);
+        }
+
+        if(!$dry && is_int($this->tree->content_model)) {
+            $this->content_model = $this->tree->content_model;
+            $this->tree->content_model = null;
+
+        } elseif($token['type'] === self::ENDTAG) {
+            $this->content_model = self::PCDATA;
+        }
+    }
+}
+
diff --git a/inc/3rdparty/libraries/html5/TreeBuilder.php b/inc/3rdparty/libraries/html5/TreeBuilder.php
new file mode 100644
index 00000000..2f5244f9
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/TreeBuilder.php
@@ -0,0 +1,3840 @@
+<?php
+
+/*
+
+Copyright 2007 Jeroen van der Meer <http://jero.net/>
+Copyright 2009 Edward Z. Yang <edwardzyang@thewritingpot.com>
+
+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.
+
+*/
+
+// Tags for FIX ME!!!: (in order of priority)
+//      XXX - should be fixed NAO!
+//      XERROR - with regards to parse errors
+//      XSCRIPT - with regards to scripting mode
+//      XENCODING - with regards to encoding (for reparsing tests)
+//      XDOM - DOM specific code (tagName is explicitly not marked).
+//          this is not (yet) in helper functions.
+
+class HTML5_TreeBuilder {
+    public $stack = array();
+    public $content_model;
+
+    private $mode;
+    private $original_mode;
+    private $secondary_mode;
+    private $dom;
+    // Whether or not normal insertion of nodes should actually foster
+    // parent (used in one case in spec)
+    private $foster_parent = false;
+    private $a_formatting  = array();
+
+    private $head_pointer = null;
+    private $form_pointer = null;
+
+    private $flag_frameset_ok = true;
+    private $flag_force_quirks = false;
+    private $ignored = false;
+    private $quirks_mode = null;
+    // this gets to 2 when we want to ignore the next lf character, and
+    // is decrement at the beginning of each processed token (this way,
+    // code can check for (bool)$ignore_lf_token, but it phases out
+    // appropriately)
+    private $ignore_lf_token = 0;
+    private $fragment = false;
+    private $root;
+
+    private $scoping = array('applet','button','caption','html','marquee','object','table','td','th', 'svg:foreignObject');
+    private $formatting = array('a','b','big','code','em','font','i','nobr','s','small','strike','strong','tt','u');
+    // dl and ds are speculative
+    private $special = array('address','area','article','aside','base','basefont','bgsound',
+    'blockquote','body','br','center','col','colgroup','command','dc','dd','details','dir','div','dl','ds',
+    'dt','embed','fieldset','figure','footer','form','frame','frameset','h1','h2','h3','h4','h5',
+    'h6','head','header','hgroup','hr','iframe','img','input','isindex','li','link',
+    'listing','menu','meta','nav','noembed','noframes','noscript','ol',
+    'p','param','plaintext','pre','script','select','spacer','style',
+    'tbody','textarea','tfoot','thead','title','tr','ul','wbr');
+
+    private $pendingTableCharacters;
+    private $pendingTableCharactersDirty;
+
+    // Tree construction modes
+    const INITIAL           = 0;
+    const BEFORE_HTML       = 1;
+    const BEFORE_HEAD       = 2;
+    const IN_HEAD           = 3;
+    const IN_HEAD_NOSCRIPT  = 4;
+    const AFTER_HEAD        = 5;
+    const IN_BODY           = 6;
+    const IN_CDATA_RCDATA   = 7;
+    const IN_TABLE          = 8;
+    const IN_TABLE_TEXT     = 9;
+    const IN_CAPTION        = 10;
+    const IN_COLUMN_GROUP   = 11;
+    const IN_TABLE_BODY     = 12;
+    const IN_ROW            = 13;
+    const IN_CELL           = 14;
+    const IN_SELECT         = 15;
+    const IN_SELECT_IN_TABLE= 16;
+    const IN_FOREIGN_CONTENT= 17;
+    const AFTER_BODY        = 18;
+    const IN_FRAMESET       = 19;
+    const AFTER_FRAMESET    = 20;
+    const AFTER_AFTER_BODY  = 21;
+    const AFTER_AFTER_FRAMESET = 22;
+
+    /**
+     * Converts a magic number to a readable name. Use for debugging.
+     */
+    private function strConst($number) {
+        static $lookup;
+        if (!$lookup) {
+            $lookup = array();
+            $r = new ReflectionClass('HTML5_TreeBuilder');
+            $consts = $r->getConstants();
+            foreach ($consts as $const => $num) {
+                if (!is_int($num)) continue;
+                $lookup[$num] = $const;
+            }
+        }
+        return $lookup[$number];
+    }
+
+    // The different types of elements.
+    const SPECIAL    = 100;
+    const SCOPING    = 101;
+    const FORMATTING = 102;
+    const PHRASING   = 103;
+
+    // Quirks modes in $quirks_mode
+    const NO_QUIRKS             = 200;
+    const QUIRKS_MODE           = 201;
+    const LIMITED_QUIRKS_MODE   = 202;
+
+    // Marker to be placed in $a_formatting
+    const MARKER     = 300;
+
+    // Namespaces for foreign content
+    const NS_HTML   = null; // to prevent DOM from requiring NS on everything
+    const NS_MATHML = 'http://www.w3.org/1998/Math/MathML';
+    const NS_SVG    = 'http://www.w3.org/2000/svg';
+    const NS_XLINK  = 'http://www.w3.org/1999/xlink';
+    const NS_XML    = 'http://www.w3.org/XML/1998/namespace';
+    const NS_XMLNS  = 'http://www.w3.org/2000/xmlns/';
+
+    // Different types of scopes to test for elements
+    const SCOPE = 0;
+    const SCOPE_LISTITEM = 1;
+    const SCOPE_TABLE = 2;
+
+    public function __construct() {
+        $this->mode = self::INITIAL;
+        $this->dom = new DOMDocument;
+
+        $this->dom->encoding = 'UTF-8';
+        $this->dom->preserveWhiteSpace = true;
+        $this->dom->substituteEntities = true;
+        $this->dom->strictErrorChecking = false;
+    }
+
+    // Process tag tokens
+    public function emitToken($token, $mode = null) {
+        // XXX: ignore parse errors... why are we emitting them, again?
+        if ($token['type'] === HTML5_Tokenizer::PARSEERROR) return;
+        if ($mode === null) $mode = $this->mode;
+
+        /*
+        $backtrace = debug_backtrace();
+        if ($backtrace[1]['class'] !== 'HTML5_TreeBuilder') echo "--\n";
+        echo $this->strConst($mode);
+        if ($this->original_mode) echo " (originally ".$this->strConst($this->original_mode).")";
+        echo "\n  ";
+        token_dump($token);
+        $this->printStack();
+        $this->printActiveFormattingElements();
+        if ($this->foster_parent) echo "  -> this is a foster parent mode\n";
+        if ($this->flag_frameset_ok) echo "  -> frameset ok\n";
+        */
+
+        if ($this->ignore_lf_token) $this->ignore_lf_token--;
+        $this->ignored = false;
+        // indenting is a little wonky, this can be changed later on
+        switch ($mode) {
+
+    case self::INITIAL:
+
+        /* A character token that is one of U+0009 CHARACTER TABULATION,
+         * U+000A LINE FEED (LF), U+000C FORM FEED (FF),  or U+0020 SPACE */
+        if ($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Ignore the token. */
+            $this->ignored = true;
+        } elseif ($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            if (
+                $token['name'] !== 'html' || !empty($token['public']) ||
+                !empty($token['system']) || $token !== 'about:legacy-compat'
+            ) {
+                /* If the DOCTYPE token's name is not a case-sensitive match
+                 * for the string "html", or if the token's public identifier
+                 * is not missing, or if the token's system identifier is
+                 * neither missing nor a case-sensitive match for the string
+                 * "about:legacy-compat", then there is a parse error (this
+                 * is the DOCTYPE parse error). */
+                // DOCTYPE parse error
+            }
+            /* Append a DocumentType node to the Document node, with the name
+             * attribute set to the name given in the DOCTYPE token, or the
+             * empty string if the name was missing; the publicId attribute
+             * set to the public identifier given in the DOCTYPE token, or
+             * the empty string if the public identifier was missing; the
+             * systemId attribute set to the system identifier given in the
+             * DOCTYPE token, or the empty string if the system identifier
+             * was missing; and the other attributes specific to
+             * DocumentType objects set to null and empty lists as
+             * appropriate. Associate the DocumentType node with the
+             * Document object so that it is returned as the value of the
+             * doctype attribute of the Document object. */
+            if (!isset($token['public'])) $token['public'] = null;
+            if (!isset($token['system'])) $token['system'] = null;
+            // XDOM
+            // Yes this is hacky. I'm kind of annoyed that I can't appendChild
+            // a doctype to DOMDocument. Maybe I haven't chanted the right
+            // syllables.
+            $impl = new DOMImplementation();
+            // This call can fail for particularly pathological cases (namely,
+            // the qualifiedName parameter ($token['name']) could be missing.
+            if ($token['name']) {
+                $doctype = $impl->createDocumentType($token['name'], $token['public'], $token['system']);
+                $this->dom->appendChild($doctype);
+            } else {
+                // It looks like libxml's not actually *able* to express this case.
+                // So... don't.
+                $this->dom->emptyDoctype = true;
+            }
+            $public = is_null($token['public']) ? false : strtolower($token['public']);
+            $system = is_null($token['system']) ? false : strtolower($token['system']);
+            $publicStartsWithForQuirks = array(
+             "+//silmaril//dtd html pro v0r11 19970101//",
+             "-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
+             "-//as//dtd html 3.0 aswedit + extensions//",
+             "-//ietf//dtd html 2.0 level 1//",
+             "-//ietf//dtd html 2.0 level 2//",
+             "-//ietf//dtd html 2.0 strict level 1//",
+             "-//ietf//dtd html 2.0 strict level 2//",
+             "-//ietf//dtd html 2.0 strict//",
+             "-//ietf//dtd html 2.0//",
+             "-//ietf//dtd html 2.1e//",
+             "-//ietf//dtd html 3.0//",
+             "-//ietf//dtd html 3.2 final//",
+             "-//ietf//dtd html 3.2//",
+             "-//ietf//dtd html 3//",
+             "-//ietf//dtd html level 0//",
+             "-//ietf//dtd html level 1//",
+             "-//ietf//dtd html level 2//",
+             "-//ietf//dtd html level 3//",
+             "-//ietf//dtd html strict level 0//",
+             "-//ietf//dtd html strict level 1//",
+             "-//ietf//dtd html strict level 2//",
+             "-//ietf//dtd html strict level 3//",
+             "-//ietf//dtd html strict//",
+             "-//ietf//dtd html//",
+             "-//metrius//dtd metrius presentational//",
+             "-//microsoft//dtd internet explorer 2.0 html strict//",
+             "-//microsoft//dtd internet explorer 2.0 html//",
+             "-//microsoft//dtd internet explorer 2.0 tables//",
+             "-//microsoft//dtd internet explorer 3.0 html strict//",
+             "-//microsoft//dtd internet explorer 3.0 html//",
+             "-//microsoft//dtd internet explorer 3.0 tables//",
+             "-//netscape comm. corp.//dtd html//",
+             "-//netscape comm. corp.//dtd strict html//",
+             "-//o'reilly and associates//dtd html 2.0//",
+             "-//o'reilly and associates//dtd html extended 1.0//",
+             "-//o'reilly and associates//dtd html extended relaxed 1.0//",
+             "-//spyglass//dtd html 2.0 extended//",
+             "-//sq//dtd html 2.0 hotmetal + extensions//",
+             "-//sun microsystems corp.//dtd hotjava html//",
+             "-//sun microsystems corp.//dtd hotjava strict html//",
+             "-//w3c//dtd html 3 1995-03-24//",
+             "-//w3c//dtd html 3.2 draft//",
+             "-//w3c//dtd html 3.2 final//",
+             "-//w3c//dtd html 3.2//",
+             "-//w3c//dtd html 3.2s draft//",
+             "-//w3c//dtd html 4.0 frameset//",
+             "-//w3c//dtd html 4.0 transitional//",
+             "-//w3c//dtd html experimental 19960712//",
+             "-//w3c//dtd html experimental 970421//",
+             "-//w3c//dtd w3 html//",
+             "-//w3o//dtd w3 html 3.0//",
+             "-//webtechs//dtd mozilla html 2.0//",
+             "-//webtechs//dtd mozilla html//",
+            );
+            $publicSetToForQuirks = array(
+             "-//w3o//dtd w3 html strict 3.0//",
+             "-/w3c/dtd html 4.0 transitional/en",
+             "html",
+            );
+            $publicStartsWithAndSystemForQuirks = array(
+             "-//w3c//dtd html 4.01 frameset//",
+             "-//w3c//dtd html 4.01 transitional//",
+            );
+            $publicStartsWithForLimitedQuirks = array(
+             "-//w3c//dtd xhtml 1.0 frameset//",
+             "-//w3c//dtd xhtml 1.0 transitional//",
+            );
+            $publicStartsWithAndSystemForLimitedQuirks = array(
+             "-//w3c//dtd html 4.01 frameset//",
+             "-//w3c//dtd html 4.01 transitional//",
+            );
+            // first, do easy checks
+            if (
+                !empty($token['force-quirks']) ||
+                strtolower($token['name']) !== 'html'
+            ) {
+                $this->quirks_mode = self::QUIRKS_MODE;
+            } else {
+                do {
+                    if ($system) {
+                        foreach ($publicStartsWithAndSystemForQuirks as $x) {
+                            if (strncmp($public, $x, strlen($x)) === 0) {
+                                $this->quirks_mode = self::QUIRKS_MODE;
+                                break;
+                            }
+                        }
+                        if (!is_null($this->quirks_mode)) break;
+                        foreach ($publicStartsWithAndSystemForLimitedQuirks as $x) {
+                            if (strncmp($public, $x, strlen($x)) === 0) {
+                                $this->quirks_mode = self::LIMITED_QUIRKS_MODE;
+                                break;
+                            }
+                        }
+                        if (!is_null($this->quirks_mode)) break;
+                    }
+                    foreach ($publicSetToForQuirks as $x) {
+                        if ($public === $x) {
+                            $this->quirks_mode = self::QUIRKS_MODE;
+                            break;
+                        }
+                    }
+                    if (!is_null($this->quirks_mode)) break;
+                    foreach ($publicStartsWithForLimitedQuirks as $x) {
+                        if (strncmp($public, $x, strlen($x)) === 0) {
+                            $this->quirks_mode = self::LIMITED_QUIRKS_MODE;
+                        }
+                    }
+                    if (!is_null($this->quirks_mode)) break;
+                    if ($system === "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
+                        $this->quirks_mode = self::QUIRKS_MODE;
+                        break;
+                    }
+                    foreach ($publicStartsWithForQuirks as $x) {
+                        if (strncmp($public, $x, strlen($x)) === 0) {
+                            $this->quirks_mode = self::QUIRKS_MODE;
+                            break;
+                        }
+                    }
+                    if (is_null($this->quirks_mode)) {
+                        $this->quirks_mode = self::NO_QUIRKS;
+                    }
+                } while (false);
+            }
+            $this->mode = self::BEFORE_HTML;
+        } else {
+            // parse error
+            /* Switch the insertion mode to "before html", then reprocess the
+             * current token. */
+            $this->mode = self::BEFORE_HTML;
+            $this->quirks_mode = self::QUIRKS_MODE;
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::BEFORE_HTML:
+
+        /* A DOCTYPE token */
+        if($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // Parse error. Ignore the token.
+            $this->ignored = true;
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the Document object with the data
+            attribute set to the data given in the comment token. */
+            // XDOM
+            $comment = $this->dom->createComment($token['data']);
+            $this->dom->appendChild($comment);
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE */
+        } elseif($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Ignore the token. */
+            $this->ignored = true;
+
+        /* A start tag whose tag name is "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] == 'html') {
+            /* Create an element for the token in the HTML namespace. Append it 
+             * to the Document  object. Put this element in the stack of open 
+             * elements. */
+            // XDOM
+            $html = $this->insertElement($token, false);
+            $this->dom->appendChild($html);
+            $this->stack[] = $html;
+
+            $this->mode = self::BEFORE_HEAD;
+
+        } else {
+            /* Create an html element. Append it to the Document object. Put
+             * this element in the stack of open elements. */
+            // XDOM
+            $html = $this->dom->createElementNS(self::NS_HTML, 'html');
+            $this->dom->appendChild($html);
+            $this->stack[] = $html;
+
+            /* Switch the insertion mode to "before head", then reprocess the
+             * current token. */
+            $this->mode = self::BEFORE_HEAD;
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::BEFORE_HEAD:
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Ignore the token. */
+            $this->ignored = true;
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data attribute
+            set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        /* A DOCTYPE token */
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            /* Parse error. Ignore the token */
+            $this->ignored = true;
+            // parse error
+
+        /* A start tag token with the tag name "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            /* Process the token using the rules for the "in body"
+             * insertion mode. */
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* A start tag token with the tag name "head" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'head') {
+            /* Insert an HTML element for the token. */
+            $element = $this->insertElement($token);
+
+            /* Set the head element pointer to this new element node. */
+            $this->head_pointer = $element;
+
+            /* Change the insertion mode to "in head". */
+            $this->mode = self::IN_HEAD;
+
+        /* An end tag whose tag name is one of: "head", "body", "html", "br" */
+        } elseif(
+            $token['type'] === HTML5_Tokenizer::ENDTAG && (
+                $token['name'] === 'head' || $token['name'] === 'body' ||
+                $token['name'] === 'html' || $token['name'] === 'br'
+        )) {
+            /* Act as if a start tag token with the tag name "head" and no
+             * attributes had been seen, then reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'head',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+            $this->emitToken($token);
+
+        /* Any other end tag */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG) {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+
+        } else {
+            /* Act as if a start tag token with the tag name "head" and no
+             * attributes had been seen, then reprocess the current token.
+             * Note: This will result in an empty head element being
+             * generated, with the current token being reprocessed in the
+             * "after head" insertion mode. */
+            $this->emitToken(array(
+                'name' => 'head',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::IN_HEAD:
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE. */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Insert the character into the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data attribute
+            set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        /* A DOCTYPE token */
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+            // parse error
+
+        /* A start tag whose tag name is "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* A start tag whose tag name is one of: "base", "command", "link" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'base' || $token['name'] === 'command' ||
+        $token['name'] === 'link')) {
+            /* Insert an HTML element for the token. Immediately pop the
+             * current node off the stack of open elements. */
+            $this->insertElement($token);
+            array_pop($this->stack);
+
+            // YYY: Acknowledge the token's self-closing flag, if it is set.
+
+        /* A start tag whose tag name is "meta" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'meta') {
+            /* Insert an HTML element for the token. Immediately pop the
+             * current node off the stack of open elements. */
+            $this->insertElement($token);
+            array_pop($this->stack);
+
+            // XERROR: Acknowledge the token's self-closing flag, if it is set.
+
+            // XENCODING: If the element has a charset attribute, and its value is a
+            // supported encoding, and the confidence is currently tentative,
+            // then change the encoding to the encoding given by the value of
+            // the charset attribute.
+            //
+            // Otherwise, if the element has a content attribute, and applying
+            // the algorithm for extracting an encoding from a Content-Type to
+            // its value returns a supported encoding encoding, and the
+            // confidence is currently tentative, then change the encoding to
+            // the encoding encoding.
+
+        /* A start tag with the tag name "title" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'title') {
+            $this->insertRCDATAElement($token);
+
+        /* A start tag whose tag name is "noscript", if the scripting flag is enabled, or
+         * A start tag whose tag name is one of: "noframes", "style" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'noscript' || $token['name'] === 'noframes' || $token['name'] === 'style')) {
+            // XSCRIPT: Scripting flag not respected
+            $this->insertCDATAElement($token);
+
+        // XSCRIPT: Scripting flag disable not implemented
+
+        /* A start tag with the tag name "script" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'script') {
+            /* 1. Create an element for the token in the HTML namespace. */
+            $node = $this->insertElement($token, false);
+
+            /* 2. Mark the element as being "parser-inserted" */
+            // Uhhh... XSCRIPT
+
+            /* 3. If the parser was originally created for the HTML
+             * fragment parsing algorithm, then mark the script element as 
+             * "already executed". (fragment case) */
+            // ditto... XSCRIPT
+
+            /* 4. Append the new element to the current node  and push it onto 
+             * the stack of open elements.  */
+            end($this->stack)->appendChild($node);
+            $this->stack[] = $node;
+            // I guess we could squash these together
+
+            /* 6. Let the original insertion mode be the current insertion mode. */
+            $this->original_mode = $this->mode;
+            /* 7. Switch the insertion mode to "in CDATA/RCDATA" */
+            $this->mode = self::IN_CDATA_RCDATA;
+            /* 5. Switch the tokeniser's content model flag to the CDATA state. */
+            $this->content_model = HTML5_Tokenizer::CDATA;
+
+        /* An end tag with the tag name "head" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'head') {
+            /* Pop the current node (which will be the head element) off the stack of open elements. */
+            array_pop($this->stack);
+
+            /* Change the insertion mode to "after head". */
+            $this->mode = self::AFTER_HEAD;
+
+        // Slight logic inversion here to minimize duplication
+        /* A start tag with the tag name "head". */
+        /* An end tag whose tag name is not one of: "body", "html", "br" */
+        } elseif(($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'head') ||
+        ($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] !== 'html' &&
+        $token['name'] !== 'body' && $token['name'] !== 'br')) {
+            // Parse error. Ignore the token.
+            $this->ignored = true;
+
+        /* Anything else */
+        } else {
+            /* Act as if an end tag token with the tag name "head" had been
+             * seen, and reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'head',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+
+            /* Then, reprocess the current token. */
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::IN_HEAD_NOSCRIPT:
+        if ($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+        } elseif ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+        } elseif ($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'noscript') {
+            /* Pop the current node (which will be a noscript element) from the
+             * stack of open elements; the new current node will be a head
+             * element. */
+            array_pop($this->stack);
+            $this->mode = self::IN_HEAD;
+        } elseif (
+            ($token['type'] === HTML5_Tokenizer::SPACECHARACTER) ||
+            ($token['type'] === HTML5_Tokenizer::COMMENT) ||
+            ($token['type'] === HTML5_Tokenizer::STARTTAG && (
+                $token['name'] === 'link' || $token['name'] === 'meta' ||
+                $token['name'] === 'noframes' || $token['name'] === 'style'))) {
+            $this->processWithRulesFor($token, self::IN_HEAD);
+        // inverted logic
+        } elseif (
+            ($token['type'] === HTML5_Tokenizer::STARTTAG && (
+                $token['name'] === 'head' || $token['name'] === 'noscript')) ||
+            ($token['type'] === HTML5_Tokenizer::ENDTAG &&
+                $token['name'] !== 'br')) {
+            // parse error
+        } else {
+            // parse error
+            $this->emitToken(array(
+                'type' => HTML5_Tokenizer::ENDTAG,
+                'name' => 'noscript',
+            ));
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::AFTER_HEAD:
+        /* Handle the token as follows: */
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Append the character to the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data attribute
+            set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        } elseif ($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        } elseif ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* A start tag token with the tag name "body" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'body') {
+            $this->insertElement($token);
+
+            /* Set the frameset-ok flag to "not ok". */
+            $this->flag_frameset_ok = false;
+
+            /* Change the insertion mode to "in body". */
+            $this->mode = self::IN_BODY;
+
+        /* A start tag token with the tag name "frameset" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'frameset') {
+            /* Insert a frameset element for the token. */
+            $this->insertElement($token);
+
+            /* Change the insertion mode to "in frameset". */
+            $this->mode = self::IN_FRAMESET;
+
+        /* A start tag token whose tag name is one of: "base", "link", "meta",
+        "script", "style", "title" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('base', 'link', 'meta', 'noframes', 'script', 'style', 'title'))) {
+            // parse error
+            /* Push the node pointed to by the head element pointer onto the
+             * stack of open elements. */
+            $this->stack[] = $this->head_pointer;
+            $this->processWithRulesFor($token, self::IN_HEAD);
+            array_splice($this->stack, array_search($this->head_pointer, $this->stack, true), 1);
+
+        // inversion of specification
+        } elseif(
+        ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'head') ||
+        ($token['type'] === HTML5_Tokenizer::ENDTAG &&
+            $token['name'] !== 'body' && $token['name'] !== 'html' &&
+            $token['name'] !== 'br')) {
+            // parse error
+
+        /* Anything else */
+        } else {
+            $this->emitToken(array(
+                'name' => 'body',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+            $this->flag_frameset_ok = true;
+            $this->emitToken($token);
+        }
+        break;
+
+    case self::IN_BODY:
+        /* Handle the token as follows: */
+
+        switch($token['type']) {
+            /* A character token */
+            case HTML5_Tokenizer::CHARACTER:
+            case HTML5_Tokenizer::SPACECHARACTER:
+                /* Reconstruct the active formatting elements, if any. */
+                $this->reconstructActiveFormattingElements();
+
+                /* Append the token's character to the current node. */
+                $this->insertText($token['data']);
+
+                /* If the token is not one of U+0009 CHARACTER TABULATION,
+                 * U+000A LINE FEED (LF), U+000C FORM FEED (FF),  or U+0020
+                 * SPACE, then set the frameset-ok flag to "not ok". */
+                // i.e., if any of the characters is not whitespace
+                if (strlen($token['data']) !== strspn($token['data'], HTML5_Tokenizer::WHITESPACE)) {
+                    $this->flag_frameset_ok = false;
+                }
+            break;
+
+            /* A comment token */
+            case HTML5_Tokenizer::COMMENT:
+                /* Append a Comment node to the current node with the data
+                attribute set to the data given in the comment token. */
+                $this->insertComment($token['data']);
+            break;
+
+            case HTML5_Tokenizer::DOCTYPE:
+                // parse error
+            break;
+
+            case HTML5_Tokenizer::EOF:
+                // parse error
+            break;
+
+            case HTML5_Tokenizer::STARTTAG:
+            switch($token['name']) {
+                case 'html':
+                    // parse error
+                    /* For each attribute on the token, check to see if the
+                     * attribute is already present on the top element of the
+                     * stack of open elements. If it is not, add the attribute
+                     * and its corresponding value to that element. */
+                    foreach($token['attr'] as $attr) {
+                        if(!$this->stack[0]->hasAttribute($attr['name'])) {
+                            $this->stack[0]->setAttribute($attr['name'], $attr['value']);
+                        }
+                    }
+                break;
+
+                case 'base': case 'command': case 'link': case 'meta': case 'noframes':
+                case 'script': case 'style': case 'title':
+                    /* Process the token as if the insertion mode had been "in
+                    head". */
+                    $this->processWithRulesFor($token, self::IN_HEAD);
+                break;
+
+                /* A start tag token with the tag name "body" */
+                case 'body':
+                    /* Parse error. If the second element on the stack of open
+                    elements is not a body element, or, if the stack of open
+                    elements has only one node on it, then ignore the token.
+                    (fragment case) */
+                    if(count($this->stack) === 1 || $this->stack[1]->tagName !== 'body') {
+                        $this->ignored = true;
+                        // Ignore
+
+                    /* Otherwise, for each attribute on the token, check to see
+                    if the attribute is already present on the body element (the
+                    second element)    on the stack of open elements. If it is not,
+                    add the attribute and its corresponding value to that
+                    element. */
+                    } else {
+                        foreach($token['attr'] as $attr) {
+                            if(!$this->stack[1]->hasAttribute($attr['name'])) {
+                                $this->stack[1]->setAttribute($attr['name'], $attr['value']);
+                            }
+                        }
+                    }
+                break;
+
+                case 'frameset':
+                    // parse error
+                    /* If the second element on the stack of open elements is
+                     * not a body element, or, if the stack of open elements
+                     * has only one node on it, then ignore the token.
+                     * (fragment case) */
+                    if(count($this->stack) === 1 || $this->stack[1]->tagName !== 'body') {
+                        $this->ignored = true;
+                        // Ignore
+                    } elseif (!$this->flag_frameset_ok) {
+                        $this->ignored = true;
+                        // Ignore
+                    } else {
+                        /* 1. Remove the second element on the stack of open 
+                         * elements from its parent node, if it has one.  */
+                        if($this->stack[1]->parentNode) {
+                            $this->stack[1]->parentNode->removeChild($this->stack[1]);
+                        }
+
+                        /* 2. Pop all the nodes from the bottom of the stack of 
+                         * open elements, from the current node up to the root 
+                         * html element. */
+                        array_splice($this->stack, 1);
+
+                        $this->insertElement($token);
+                        $this->mode = self::IN_FRAMESET;
+                    }
+                break;
+
+                // in spec, there is a diversion here
+
+                case 'address': case 'article': case 'aside': case 'blockquote':
+                case 'center': case 'datagrid': case 'details': case 'dir':
+                case 'div': case 'dl': case 'fieldset': case 'figure': case 'footer':
+                case 'header': case 'hgroup': case 'menu': case 'nav':
+                case 'ol': case 'p': case 'section': case 'ul':
+                    /* If the stack of open elements has a p element in scope,
+                    then act as if an end tag with the tag name p had been
+                    seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+                break;
+
+                /* A start tag whose tag name is one of: "h1", "h2", "h3", "h4",
+                "h5", "h6" */
+                case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
+                    /* If the stack of open elements has a p  element in scope,
+                    then act as if an end tag with the tag name p had been seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* If the current node is an element whose tag name is one
+                     * of "h1", "h2", "h3", "h4", "h5", or "h6", then this is a
+                     * parse error; pop the current node off the stack of open
+                     * elements. */
+                    $peek = array_pop($this->stack);
+                    if (in_array($peek->tagName, array("h1", "h2", "h3", "h4", "h5", "h6"))) {
+                        // parse error
+                    } else {
+                        $this->stack[] = $peek;
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+                break;
+
+                case 'pre': case 'listing':
+                    /* If the stack of open elements has a p  element in scope,
+                    then act as if an end tag with the tag name p had been seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+                    $this->insertElement($token);
+                    /* If the next token is a U+000A LINE FEED (LF) character
+                     * token, then ignore that token and move on to the next
+                     * one. (Newlines at the start of pre blocks are ignored as
+                     * an authoring convenience.) */
+                    $this->ignore_lf_token = 2;
+                    $this->flag_frameset_ok = false;
+                break;
+
+                /* A start tag whose tag name is "form" */
+                case 'form':
+                    /* If the form element pointer is not null, ignore the
+                    token with a parse error. */
+                    if($this->form_pointer !== null) {
+                        $this->ignored = true;
+                        // Ignore.
+
+                    /* Otherwise: */
+                    } else {
+                        /* If the stack of open elements has a p element in
+                        scope, then act as if an end tag with the tag name p
+                        had been seen. */
+                        if($this->elementInScope('p')) {
+                            $this->emitToken(array(
+                                'name' => 'p',
+                                'type' => HTML5_Tokenizer::ENDTAG
+                            ));
+                        }
+
+                        /* Insert an HTML element for the token, and set the
+                        form element pointer to point to the element created. */
+                        $element = $this->insertElement($token);
+                        $this->form_pointer = $element;
+                    }
+                break;
+
+                // condensed specification
+                case 'li': case 'dc': case 'dd': case 'ds': case 'dt':
+                    /* 1. Set the frameset-ok flag to "not ok". */
+                    $this->flag_frameset_ok = false;
+
+                    $stack_length = count($this->stack) - 1;
+                    for($n = $stack_length; 0 <= $n; $n--) {
+                        /* 2. Initialise node to be the current node (the
+                        bottommost node of the stack). */
+                        $stop = false;
+                        $node = $this->stack[$n];
+                        $cat  = $this->getElementCategory($node);
+
+                        // for case 'li':
+                        /* 3. If node is an li element, then act as if an end
+                         * tag with the tag name "li" had been seen, then jump
+                         * to the last step.  */
+                        // for case 'dc': case 'dd': case 'ds': case 'dt':
+                        /* If node is a dc, dd, ds or dt element, then act as if an end
+                         * tag with the same tag name as node had been seen, then
+                         * jump to the last step. */
+                        if(($token['name'] === 'li' && $node->tagName === 'li') ||
+                        ($token['name'] !== 'li' && ($node->tagName == 'dc' || $node->tagName === 'dd' || $node->tagName == 'ds' || $node->tagName === 'dt'))) { // limited conditional
+                            $this->emitToken(array(
+                                'type' => HTML5_Tokenizer::ENDTAG,
+                                'name' => $node->tagName,
+                            ));
+                            break;
+                        }
+
+                        /* 4. If node is not in the formatting category, and is
+                        not    in the phrasing category, and is not an address,
+                        div or p element, then stop this algorithm. */
+                        if($cat !== self::FORMATTING && $cat !== self::PHRASING &&
+                        $node->tagName !== 'address' && $node->tagName !== 'div' &&
+                        $node->tagName !== 'p') {
+                            break;
+                        }
+
+                        /* 5. Otherwise, set node to the previous entry in the
+                         * stack of open elements and return to step 2. */
+                    }
+
+                    /* 6. This is the last step. */
+
+                    /* If the stack of open elements has a p  element in scope,
+                    then act as if an end tag with the tag name p had been
+                    seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Finally, insert an HTML element with the same tag
+                    name as the    token's. */
+                    $this->insertElement($token);
+                break;
+
+                /* A start tag token whose tag name is "plaintext" */
+                case 'plaintext':
+                    /* If the stack of open elements has a p  element in scope,
+                    then act as if an end tag with the tag name p had been
+                    seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    $this->content_model = HTML5_Tokenizer::PLAINTEXT;
+                break;
+
+                // more diversions
+
+                /* A start tag whose tag name is "a" */
+                case 'a':
+                    /* If the list of active formatting elements contains
+                    an element whose tag name is "a" between the end of the
+                    list and the last marker on the list (or the start of
+                    the list if there is no marker on the list), then this
+                    is a parse error; act as if an end tag with the tag name
+                    "a" had been seen, then remove that element from the list
+                    of active formatting elements and the stack of open
+                    elements if the end tag didn't already remove it (it
+                    might not have if the element is not in table scope). */
+                    $leng = count($this->a_formatting);
+
+                    for($n = $leng - 1; $n >= 0; $n--) {
+                        if($this->a_formatting[$n] === self::MARKER) {
+                            break;
+
+                        } elseif($this->a_formatting[$n]->tagName === 'a') {
+                            $a = $this->a_formatting[$n];
+                            $this->emitToken(array(
+                                'name' => 'a',
+                                'type' => HTML5_Tokenizer::ENDTAG
+                            ));
+                            if (in_array($a, $this->a_formatting)) {
+                                $a_i = array_search($a, $this->a_formatting, true);
+                                if($a_i !== false) array_splice($this->a_formatting, $a_i, 1);
+                            }
+                            if (in_array($a, $this->stack)) {
+                                $a_i = array_search($a, $this->stack, true);
+                                if ($a_i !== false) array_splice($this->stack, $a_i, 1);
+                            }
+                            break;
+                        }
+                    }
+
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $el = $this->insertElement($token);
+
+                    /* Add that element to the list of active formatting
+                    elements. */
+                    $this->a_formatting[] = $el;
+                break;
+
+                case 'b': case 'big': case 'code': case 'em': case 'font': case 'i':
+                case 's': case 'small': case 'strike':
+                case 'strong': case 'tt': case 'u':
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $el = $this->insertElement($token);
+
+                    /* Add that element to the list of active formatting
+                    elements. */
+                    $this->a_formatting[] = $el;
+                break;
+
+                case 'nobr':
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* If the stack of open elements has a nobr element in
+                     * scope, then this is a parse error; act as if an end tag
+                     * with the tag name "nobr" had been seen, then once again
+                     * reconstruct the active formatting elements, if any. */
+                    if ($this->elementInScope('nobr')) {
+                        $this->emitToken(array(
+                            'name' => 'nobr',
+                            'type' => HTML5_Tokenizer::ENDTAG,
+                        ));
+                        $this->reconstructActiveFormattingElements();
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $el = $this->insertElement($token);
+
+                    /* Add that element to the list of active formatting
+                    elements. */
+                    $this->a_formatting[] = $el;
+                break;
+
+                // another diversion
+
+                /* A start tag token whose tag name is "button" */
+                case 'button':
+                    /* If the stack of open elements has a button element in scope,
+                    then this is a parse error; act as if an end tag with the tag
+                    name "button" had been seen, then reprocess the token. (We don't
+                    do that. Unnecessary.) (I hope you're right! -- ezyang) */
+                    if($this->elementInScope('button')) {
+                        $this->emitToken(array(
+                            'name' => 'button',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    /* Insert a marker at the end of the list of active
+                    formatting elements. */
+                    $this->a_formatting[] = self::MARKER;
+
+                    $this->flag_frameset_ok = false;
+                break;
+
+                case 'applet': case 'marquee': case 'object':
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    /* Insert a marker at the end of the list of active
+                    formatting elements. */
+                    $this->a_formatting[] = self::MARKER;
+
+                    $this->flag_frameset_ok = false;
+                break;
+
+                // spec diversion
+
+                /* A start tag whose tag name is "table" */
+                case 'table':
+                    /* If the Document is not set to quirks mode, and the 
+                     * stack of open elements has a p element in scope, then 
+                     * act as if an end tag with the tag name "p" had been 
+                     * seen. */
+                    if($this->quirks_mode !== self::QUIRKS_MODE &&
+                    $this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    $this->flag_frameset_ok = false;
+
+                    /* Change the insertion mode to "in table". */
+                    $this->mode = self::IN_TABLE;
+                break;
+
+                /* A start tag whose tag name is one of: "area", "basefont",
+                "bgsound", "br", "embed", "img", "param", "spacer", "wbr" */
+                case 'area': case 'basefont': case 'bgsound': case 'br':
+                case 'embed': case 'img': case 'input': case 'keygen': case 'spacer':
+                case 'wbr':
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    /* Immediately pop the current node off the stack of open elements. */
+                    array_pop($this->stack);
+
+                    // YYY: Acknowledge the token's self-closing flag, if it is set.
+
+                    $this->flag_frameset_ok = false;
+                break;
+
+                case 'param': case 'source':
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    /* Immediately pop the current node off the stack of open elements. */
+                    array_pop($this->stack);
+
+                    // YYY: Acknowledge the token's self-closing flag, if it is set.
+                break;
+
+                /* A start tag whose tag name is "hr" */
+                case 'hr':
+                    /* If the stack of open elements has a p element in scope,
+                    then act as if an end tag with the tag name p had been seen. */
+                    if($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    /* Immediately pop the current node off the stack of open elements. */
+                    array_pop($this->stack);
+
+                    // YYY: Acknowledge the token's self-closing flag, if it is set.
+
+                    $this->flag_frameset_ok = false;
+                break;
+
+                /* A start tag whose tag name is "image" */
+                case 'image':
+                    /* Parse error. Change the token's tag name to "img" and
+                    reprocess it. (Don't ask.) */
+                    $token['name'] = 'img';
+                    $this->emitToken($token);
+                break;
+
+                /* A start tag whose tag name is "isindex" */
+                case 'isindex':
+                    /* Parse error. */
+
+                    /* If the form element pointer is not null,
+                    then ignore the token. */
+                    if($this->form_pointer === null) {
+                        /* Act as if a start tag token with the tag name "form" had
+                        been seen. */
+                        /* If the token has an attribute called "action", set
+                         * the action attribute on the resulting form
+                         * element to the value of the "action" attribute of
+                         * the token. */
+                        $attr = array();
+                        $action = $this->getAttr($token, 'action');
+                        if ($action !== false) {
+                            $attr[] = array('name' => 'action', 'value' => $action);
+                        }
+                        $this->emitToken(array(
+                            'name' => 'form',
+                            'type' => HTML5_Tokenizer::STARTTAG,
+                            'attr' => $attr
+                        ));
+
+                        /* Act as if a start tag token with the tag name "hr" had
+                        been seen. */
+                        $this->emitToken(array(
+                            'name' => 'hr',
+                            'type' => HTML5_Tokenizer::STARTTAG,
+                            'attr' => array()
+                        ));
+
+                        /* Act as if a start tag token with the tag name "label"
+                        had been seen. */
+                        $this->emitToken(array(
+                            'name' => 'label',
+                            'type' => HTML5_Tokenizer::STARTTAG,
+                            'attr' => array()
+                        ));
+
+                        /* Act as if a stream of character tokens had been seen. */
+                        $prompt = $this->getAttr($token, 'prompt');
+                        if ($prompt === false) {
+                            $prompt = 'This is a searchable index. '.
+                            'Insert your search keywords here: ';
+                        }
+                        $this->emitToken(array(
+                            'data' => $prompt,
+                            'type' => HTML5_Tokenizer::CHARACTER,
+                        ));
+
+                        /* Act as if a start tag token with the tag name "input"
+                        had been seen, with all the attributes from the "isindex"
+                        token, except with the "name" attribute set to the value
+                        "isindex" (ignoring any explicit "name" attribute). */
+                        $attr = array();
+                        foreach ($token['attr'] as $keypair) {
+                            if ($keypair['name'] === 'name' || $keypair['name'] === 'action' ||
+                                $keypair['name'] === 'prompt') continue;
+                            $attr[] = $keypair;
+                        }
+                        $attr[] = array('name' => 'name', 'value' => 'isindex');
+
+                        $this->emitToken(array(
+                            'name' => 'input',
+                            'type' => HTML5_Tokenizer::STARTTAG,
+                            'attr' => $attr
+                        ));
+
+                        /* Act as if an end tag token with the tag name "label"
+                        had been seen. */
+                        $this->emitToken(array(
+                            'name' => 'label',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+
+                        /* Act as if a start tag token with the tag name "hr" had
+                        been seen. */
+                        $this->emitToken(array(
+                            'name' => 'hr',
+                            'type' => HTML5_Tokenizer::STARTTAG
+                        ));
+
+                        /* Act as if an end tag token with the tag name "form" had
+                        been seen. */
+                        $this->emitToken(array(
+                            'name' => 'form',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    } else {
+                        $this->ignored = true;
+                    }
+                break;
+
+                /* A start tag whose tag name is "textarea" */
+                case 'textarea':
+                    $this->insertElement($token);
+
+                    /* If the next token is a U+000A LINE FEED (LF)
+                     * character token, then ignore that token and move on to
+                     * the next one. (Newlines at the start of textarea
+                     * elements are ignored as an authoring convenience.)
+                     * need flag, see also <pre> */
+                    $this->ignore_lf_token = 2;
+
+                    $this->original_mode = $this->mode;
+                    $this->flag_frameset_ok = false;
+                    $this->mode = self::IN_CDATA_RCDATA;
+
+                    /* Switch the tokeniser's content model flag to the
+                    RCDATA state. */
+                    $this->content_model = HTML5_Tokenizer::RCDATA;
+                break;
+
+                /* A start tag token whose tag name is "xmp" */
+                case 'xmp':
+                    /* If the stack of open elements has a p element in
+                    scope, then act as if an end tag with the tag name
+                    "p" has been seen. */
+                    if ($this->elementInScope('p')) {
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::ENDTAG
+                        ));
+                    }
+
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    $this->flag_frameset_ok = false;
+
+                    $this->insertCDATAElement($token);
+                break;
+
+                case 'iframe':
+                    $this->flag_frameset_ok = false;
+                    $this->insertCDATAElement($token);
+                break;
+
+                case 'noembed': case 'noscript':
+                    // XSCRIPT: should check scripting flag
+                    $this->insertCDATAElement($token);
+                break;
+
+                /* A start tag whose tag name is "select" */
+                case 'select':
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    /* Insert an HTML element for the token. */
+                    $this->insertElement($token);
+
+                    $this->flag_frameset_ok = false;
+
+                    /* If the insertion mode is one of in table", "in caption",
+                     * "in column group", "in table body", "in row", or "in
+                     * cell", then switch the insertion mode to "in select in
+                     * table". Otherwise, switch the insertion mode  to "in
+                     * select". */
+                    if (
+                        $this->mode === self::IN_TABLE || $this->mode === self::IN_CAPTION ||
+                        $this->mode === self::IN_COLUMN_GROUP || $this->mode ==+self::IN_TABLE_BODY ||
+                        $this->mode === self::IN_ROW || $this->mode === self::IN_CELL
+                    ) {
+                        $this->mode = self::IN_SELECT_IN_TABLE;
+                    } else {
+                        $this->mode = self::IN_SELECT;
+                    }
+                break;
+
+                case 'option': case 'optgroup':
+                    if ($this->elementInScope('option')) {
+                        $this->emitToken(array(
+                            'name' => 'option',
+                            'type' => HTML5_Tokenizer::ENDTAG,
+                        ));
+                    }
+                    $this->reconstructActiveFormattingElements();
+                    $this->insertElement($token);
+                break;
+
+                case 'rp': case 'rt':
+                    /* If the stack of open elements has a ruby element in scope, then generate
+                     * implied end tags. If the current node is not then a ruby element, this is
+                     * a parse error; pop all the nodes from the current node up to the node
+                     * immediately before the bottommost ruby element on the stack of open elements.
+                     */
+                    if ($this->elementInScope('ruby')) {
+                        $this->generateImpliedEndTags();
+                    }
+                    $peek = false;
+                    do {
+                        if ($peek) {
+                            // parse error
+                        }
+                        $peek = array_pop($this->stack);
+                    } while ($peek->tagName !== 'ruby');
+                    $this->stack[] = $peek; // we popped one too many
+                    $this->insertElement($token);
+                break;
+
+                // spec diversion
+
+                case 'math':
+                    $this->reconstructActiveFormattingElements();
+                    $token = $this->adjustMathMLAttributes($token);
+                    $token = $this->adjustForeignAttributes($token);
+                    $this->insertForeignElement($token, self::NS_MATHML);
+                    if (isset($token['self-closing'])) {
+                        // XERROR: acknowledge the token's self-closing flag
+                        array_pop($this->stack);
+                    }
+                    if ($this->mode !== self::IN_FOREIGN_CONTENT) {
+                        $this->secondary_mode = $this->mode;
+                        $this->mode = self::IN_FOREIGN_CONTENT;
+                    }
+                break;
+
+                case 'svg':
+                    $this->reconstructActiveFormattingElements();
+                    $token = $this->adjustSVGAttributes($token);
+                    $token = $this->adjustForeignAttributes($token);
+                    $this->insertForeignElement($token, self::NS_SVG);
+                    if (isset($token['self-closing'])) {
+                        // XERROR: acknowledge the token's self-closing flag
+                        array_pop($this->stack);
+                    }
+                    if ($this->mode !== self::IN_FOREIGN_CONTENT) {
+                        $this->secondary_mode = $this->mode;
+                        $this->mode = self::IN_FOREIGN_CONTENT;
+                    }
+                break;
+
+                case 'caption': case 'col': case 'colgroup': case 'frame': case 'head':
+                case 'tbody': case 'td': case 'tfoot': case 'th': case 'thead': case 'tr':
+                    // parse error
+                break;
+
+                /* A start tag token not covered by the previous entries */
+                default:
+                    /* Reconstruct the active formatting elements, if any. */
+                    $this->reconstructActiveFormattingElements();
+
+                    $this->insertElement($token);
+                    /* This element will be a phrasing  element. */
+                break;
+            }
+            break;
+
+            case HTML5_Tokenizer::ENDTAG:
+            switch($token['name']) {
+                /* An end tag with the tag name "body" */
+                case 'body':
+                    /* If the stack of open elements does not have a body 
+                     * element in scope, this is a parse error; ignore the 
+                     * token. */
+                    if(!$this->elementInScope('body')) {
+                        $this->ignored = true;
+
+                    /* Otherwise, if there is a node in the stack of open 
+                     * elements that is not either a dc element, a dd element, 
+                     * a ds element, a dt element, an li element, an optgroup 
+                     * element, an option element, a p element, an rp element, 
+                     * an rt element, a tbody element, a td element, a tfoot 
+                     * element, a th element, a thead element, a tr element, 
+                     * the body element, or the html element, then this is a 
+                     * parse error.
+                     */
+                    } else {
+                        // XERROR: implement this check for parse error
+                    }
+
+                    /* Change the insertion mode to "after body". */
+                    $this->mode = self::AFTER_BODY;
+                break;
+
+                /* An end tag with the tag name "html" */
+                case 'html':
+                    /* Act as if an end tag with tag name "body" had been seen,
+                    then, if that token wasn't ignored, reprocess the current
+                    token. */
+                    $this->emitToken(array(
+                        'name' => 'body',
+                        'type' => HTML5_Tokenizer::ENDTAG
+                    ));
+
+                    if (!$this->ignored) $this->emitToken($token);
+                break;
+
+                case 'address': case 'article': case 'aside': case 'blockquote':
+                case 'center': case 'datagrid': case 'details': case 'dir':
+                case 'div': case 'dl': case 'fieldset': case 'footer':
+                case 'header': case 'hgroup': case 'listing': case 'menu':
+                case 'nav': case 'ol': case 'pre': case 'section': case 'ul':
+                    /* If the stack of open elements has an element in scope
+                    with the same tag name as that of the token, then generate
+                    implied end tags. */
+                    if($this->elementInScope($token['name'])) {
+                        $this->generateImpliedEndTags();
+
+                        /* Now, if the current node is not an element with
+                        the same tag name as that of the token, then this
+                        is a parse error. */
+                        // XERROR: implement parse error logic
+
+                        /* If the stack of open elements has an element in
+                        scope with the same tag name as that of the token,
+                        then pop elements from this stack until an element
+                        with that tag name has been popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while ($node->tagName !== $token['name']);
+                    } else {
+                        // parse error
+                    }
+                break;
+
+                /* An end tag whose tag name is "form" */
+                case 'form':
+                    /* Let node be the element that the form element pointer is set to. */
+                    $node = $this->form_pointer;
+                    /* Set the form element pointer  to null. */
+                    $this->form_pointer = null;
+                    /* If node is null or the stack of open elements does not 
+                        * have node in scope, then this is a parse error; ignore the token. */
+                    if ($node === null || !in_array($node, $this->stack)) {
+                        // parse error
+                        $this->ignored = true;
+                    } else {
+                        /* 1. Generate implied end tags. */
+                        $this->generateImpliedEndTags();
+                        /* 2. If the current node is not node, then this is a parse error.  */
+                        if (end($this->stack) !== $node) {
+                            // parse error
+                        }
+                        /* 3. Remove node from the stack of open elements. */
+                        array_splice($this->stack, array_search($node, $this->stack, true), 1);
+                    }
+
+                break;
+
+                /* An end tag whose tag name is "p" */
+                case 'p':
+                    /* If the stack of open elements has a p element in scope,
+                    then generate implied end tags, except for p elements. */
+                    if($this->elementInScope('p')) {
+                        /* Generate implied end tags, except for elements with
+                         * the same tag name as the token. */
+                        $this->generateImpliedEndTags(array('p'));
+
+                        /* If the current node is not a p element, then this is
+                        a parse error. */
+                        // XERROR: implement
+
+                        /* Pop elements from the stack of open elements  until
+                         * an element with the same tag name as the token has
+                         * been popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while ($node->tagName !== 'p');
+
+                    } else {
+                        // parse error
+                        $this->emitToken(array(
+                            'name' => 'p',
+                            'type' => HTML5_Tokenizer::STARTTAG,
+                        ));
+                        $this->emitToken($token);
+                    }
+                break;
+
+                /* An end tag whose tag name is "li" */
+                case 'li':
+                    /* If the stack of open elements does not have an element
+                     * in list item scope with the same tag name as that of the
+                     * token, then this is a parse error; ignore the token. */
+                    if ($this->elementInScope($token['name'], self::SCOPE_LISTITEM)) {
+                        /* Generate implied end tags, except for elements with the
+                         * same tag name as the token. */
+                        $this->generateImpliedEndTags(array($token['name']));
+                        /* If the current node is not an element with the same tag
+                         * name as that of the token, then this is a parse error. */
+                        // XERROR: parse error
+                        /* Pop elements from the stack of open elements  until an
+                         * element with the same tag name as the token has been
+                         * popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while ($node->tagName !== $token['name']);
+                    } else {
+                        // XERROR: parse error
+                    }
+                break;
+
+                /* An end tag whose tag name is "dc", "dd", "ds", "dt" */
+                case 'dc': case 'dd': case 'ds': case 'dt':
+                    if($this->elementInScope($token['name'])) {
+                        $this->generateImpliedEndTags(array($token['name']));
+
+                        /* If the current node is not an element with the same
+                        tag name as the token, then this is a parse error. */
+                        // XERROR: implement parse error
+
+                        /* Pop elements from the stack of open elements  until
+                         * an element with the same tag name as the token has
+                         * been popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while ($node->tagName !== $token['name']);
+
+                    } else {
+                        // XERROR: parse error
+                    }
+                break;
+
+                /* An end tag whose tag name is one of: "h1", "h2", "h3", "h4",
+                "h5", "h6" */
+                case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
+                    $elements = array('h1', 'h2', 'h3', 'h4', 'h5', 'h6');
+
+                    /* If the stack of open elements has in scope an element whose
+                    tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+                    generate implied end tags. */
+                    if($this->elementInScope($elements)) {
+                        $this->generateImpliedEndTags();
+
+                        /* Now, if the current node is not an element with the same
+                        tag name as that of the token, then this is a parse error. */
+                        // XERROR: implement parse error
+
+                        /* If the stack of open elements has in scope an element
+                        whose tag name is one of "h1", "h2", "h3", "h4", "h5", or
+                        "h6", then pop elements from the stack until an element
+                        with one of those tag names has been popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while (!in_array($node->tagName, $elements));
+                    } else {
+                        // parse error
+                    }
+                break;
+
+                /* An end tag whose tag name is one of: "a", "b", "big", "em",
+                "font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
+                case 'a': case 'b': case 'big': case 'code': case 'em': case 'font':
+                case 'i': case 'nobr': case 's': case 'small': case 'strike':
+                case 'strong': case 'tt': case 'u':
+                    // XERROR: generally speaking this needs parse error logic
+                    /* 1. Let the formatting element be the last element in
+                    the list of active formatting elements that:
+                        * is between the end of the list and the last scope
+                        marker in the list, if any, or the start of the list
+                        otherwise, and
+                        * has the same tag name as the token.
+                    */
+                    while(true) {
+                        for($a = count($this->a_formatting) - 1; $a >= 0; $a--) {
+                            if($this->a_formatting[$a] === self::MARKER) {
+                                break;
+
+                            } elseif($this->a_formatting[$a]->tagName === $token['name']) {
+                                $formatting_element = $this->a_formatting[$a];
+                                $in_stack = in_array($formatting_element, $this->stack, true);
+                                $fe_af_pos = $a;
+                                break;
+                            }
+                        }
+
+                        /* If there is no such node, or, if that node is
+                        also in the stack of open elements but the element
+                        is not in scope, then this is a parse error. Abort
+                        these steps. The token is ignored. */
+                        if(!isset($formatting_element) || ($in_stack &&
+                        !$this->elementInScope($token['name']))) {
+                            $this->ignored = true;
+                            break;
+
+                        /* Otherwise, if there is such a node, but that node
+                        is not in the stack of open elements, then this is a
+                        parse error; remove the element from the list, and
+                        abort these steps. */
+                        } elseif(isset($formatting_element) && !$in_stack) {
+                            unset($this->a_formatting[$fe_af_pos]);
+                            $this->a_formatting = array_merge($this->a_formatting);
+                            break;
+                        }
+
+                        /* Otherwise, there is a formatting element and that
+                         * element is in the stack and is in scope. If the
+                         * element is not the current node, this is a parse
+                         * error. In any case, proceed with the algorithm as
+                         * written in the following steps. */
+                        // XERROR: implement me
+
+                        /* 2. Let the furthest block be the topmost node in the
+                        stack of open elements that is lower in the stack
+                        than the formatting element, and is not an element in
+                        the phrasing or formatting categories. There might
+                        not be one. */
+                        $fe_s_pos = array_search($formatting_element, $this->stack, true);
+                        $length = count($this->stack);
+
+                        for($s = $fe_s_pos + 1; $s < $length; $s++) {
+                            $category = $this->getElementCategory($this->stack[$s]);
+
+                            if($category !== self::PHRASING && $category !== self::FORMATTING) {
+                                $furthest_block = $this->stack[$s];
+                                break;
+                            }
+                        }
+
+                        /* 3. If there is no furthest block, then the UA must
+                        skip the subsequent steps and instead just pop all
+                        the nodes from the bottom of the stack of open
+                        elements, from the current node up to the formatting
+                        element, and remove the formatting element from the
+                        list of active formatting elements. */
+                        if(!isset($furthest_block)) {
+                            for($n = $length - 1; $n >= $fe_s_pos; $n--) {
+                                array_pop($this->stack);
+                            }
+
+                            unset($this->a_formatting[$fe_af_pos]);
+                            $this->a_formatting = array_merge($this->a_formatting);
+                            break;
+                        }
+
+                        /* 4. Let the common ancestor be the element
+                        immediately above the formatting element in the stack
+                        of open elements. */
+                        $common_ancestor = $this->stack[$fe_s_pos - 1];
+
+                        /* 5. Let a bookmark note the position of the
+                        formatting element in the list of active formatting
+                        elements relative to the elements on either side
+                        of it in the list. */
+                        $bookmark = $fe_af_pos;
+
+                        /* 6. Let node and last node  be the furthest block.
+                        Follow these steps: */
+                        $node = $furthest_block;
+                        $last_node = $furthest_block;
+
+                        while(true) {
+                            for($n = array_search($node, $this->stack, true) - 1; $n >= 0; $n--) {
+                                /* 6.1 Let node be the element immediately
+                                prior to node in the stack of open elements. */
+                                $node = $this->stack[$n];
+
+                                /* 6.2 If node is not in the list of active
+                                formatting elements, then remove node from
+                                the stack of open elements and then go back
+                                to step 1. */
+                                if(!in_array($node, $this->a_formatting, true)) {
+                                    array_splice($this->stack, $n, 1);
+
+                                } else {
+                                    break;
+                                }
+                            }
+
+                            /* 6.3 Otherwise, if node is the formatting
+                            element, then go to the next step in the overall
+                            algorithm. */
+                            if($node === $formatting_element) {
+                                break;
+
+                            /* 6.4 Otherwise, if last node is the furthest
+                            block, then move the aforementioned bookmark to
+                            be immediately after the node in the list of
+                            active formatting elements. */
+                            } elseif($last_node === $furthest_block) {
+                                $bookmark = array_search($node, $this->a_formatting, true) + 1;
+                            }
+
+                            /* 6.5 Create an element for the token for which
+                             * the element node was created, replace the entry
+                             * for node in the list of active formatting
+                             * elements with an entry for the new element,
+                             * replace the entry for node in the stack of open
+                             * elements with an entry for the new element, and
+                             * let node be the new element. */
+                            // we don't know what the token is anymore
+                            // XDOM
+                            $clone = $node->cloneNode();
+                            $a_pos = array_search($node, $this->a_formatting, true);
+                            $s_pos = array_search($node, $this->stack, true);
+                            $this->a_formatting[$a_pos] = $clone;
+                            $this->stack[$s_pos] = $clone;
+                            $node = $clone;
+
+                            /* 6.6 Insert last node into node, first removing
+                            it from its previous parent node if any. */
+                            // XDOM
+                            if($last_node->parentNode !== null) {
+                                $last_node->parentNode->removeChild($last_node);
+                            }
+
+                            // XDOM
+                            $node->appendChild($last_node);
+
+                            /* 6.7 Let last node be node. */
+                            $last_node = $node;
+
+                            /* 6.8 Return to step 1 of this inner set of steps. */
+                        }
+
+                        /* 7. If the common ancestor node is a table, tbody,
+                         * tfoot, thead, or tr element, then, foster parent
+                         * whatever last node ended up being in the previous
+                         * step, first removing it from its previous parent
+                         * node if any. */
+                        // XDOM
+                        if ($last_node->parentNode) { // common step
+                            $last_node->parentNode->removeChild($last_node);
+                        }
+                        if (in_array($common_ancestor->tagName, array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
+                            $this->fosterParent($last_node);
+                        /* Otherwise, append whatever last node  ended up being
+                         * in the previous step to the common ancestor node,
+                         * first removing it from its previous parent node if
+                         * any. */
+                        } else {
+                            // XDOM
+                            $common_ancestor->appendChild($last_node);
+                        }
+
+                        /* 8. Create an element for the token for which the
+                         * formatting element was created. */
+                        // XDOM
+                        $clone = $formatting_element->cloneNode();
+
+                        /* 9. Take all of the child nodes of the furthest
+                        block and append them to the element created in the
+                        last step. */
+                        // XDOM
+                        while($furthest_block->hasChildNodes()) {
+                            $child = $furthest_block->firstChild;
+                            $furthest_block->removeChild($child);
+                            $clone->appendChild($child);
+                        }
+
+                        /* 10. Append that clone to the furthest block. */
+                        // XDOM
+                        $furthest_block->appendChild($clone);
+
+                        /* 11. Remove the formatting element from the list
+                        of active formatting elements, and insert the new element
+                        into the list of active formatting elements at the
+                        position of the aforementioned bookmark. */
+                        $fe_af_pos = array_search($formatting_element, $this->a_formatting, true);
+                        array_splice($this->a_formatting, $fe_af_pos, 1);
+
+                        $af_part1 = array_slice($this->a_formatting, 0, $bookmark - 1);
+                        $af_part2 = array_slice($this->a_formatting, $bookmark);
+                        $this->a_formatting = array_merge($af_part1, array($clone), $af_part2);
+
+                        /* 12. Remove the formatting element from the stack
+                        of open elements, and insert the new element into the stack
+                        of open elements immediately below the position of the
+                        furthest block in that stack. */
+                        $fe_s_pos = array_search($formatting_element, $this->stack, true);
+                        array_splice($this->stack, $fe_s_pos, 1);
+
+                        $fb_s_pos = array_search($furthest_block, $this->stack, true);
+                        $s_part1 = array_slice($this->stack, 0, $fb_s_pos + 1);
+                        $s_part2 = array_slice($this->stack, $fb_s_pos + 1);
+                        $this->stack = array_merge($s_part1, array($clone), $s_part2);
+
+                        /* 13. Jump back to step 1 in this series of steps. */
+                        unset($formatting_element, $fe_af_pos, $fe_s_pos, $furthest_block);
+                    }
+                break;
+
+                case 'applet': case 'button': case 'marquee': case 'object':
+                    /* If the stack of open elements has an element in scope whose
+                    tag name matches the tag name of the token, then generate implied
+                    tags. */
+                    if($this->elementInScope($token['name'])) {
+                        $this->generateImpliedEndTags();
+
+                        /* Now, if the current node is not an element with the same
+                        tag name as the token, then this is a parse error. */
+                        // XERROR: implement logic
+
+                        /* Pop elements from the stack of open elements  until
+                         * an element with the same tag name as the token has
+                         * been popped from the stack. */
+                        do {
+                            $node = array_pop($this->stack);
+                        } while ($node->tagName !== $token['name']);
+
+                        /* Clear the list of active formatting elements up to the
+                         * last marker. */
+                        $keys = array_keys($this->a_formatting, self::MARKER, true);
+                        $marker = end($keys);
+
+                        for($n = count($this->a_formatting) - 1; $n > $marker; $n--) {
+                            array_pop($this->a_formatting);
+                        }
+                    } else {
+                        // parse error
+                    }
+                break;
+
+                case 'br':
+                    // Parse error
+                    $this->emitToken(array(
+                        'name' => 'br',
+                        'type' => HTML5_Tokenizer::STARTTAG,
+                    ));
+                break;
+
+                /* An end tag token not covered by the previous entries */
+                default:
+                    for($n = count($this->stack) - 1; $n >= 0; $n--) {
+                        /* Initialise node to be the current node (the bottommost
+                        node of the stack). */
+                        $node = $this->stack[$n];
+
+                        /* If node has the same tag name as the end tag token,
+                        then: */
+                        if($token['name'] === $node->tagName) {
+                            /* Generate implied end tags. */
+                            $this->generateImpliedEndTags();
+
+                            /* If the tag name of the end tag token does not
+                            match the tag name of the current node, this is a
+                            parse error. */
+                            // XERROR: implement this
+
+                            /* Pop all the nodes from the current node up to
+                            node, including node, then stop these steps. */
+                            // XSKETCHY
+                            do {
+                                $pop = array_pop($this->stack);
+                            } while ($pop !== $node);
+                            break;
+
+                        } else {
+                            $category = $this->getElementCategory($node);
+
+                            if($category !== self::FORMATTING && $category !== self::PHRASING) {
+                                /* Otherwise, if node is in neither the formatting
+                                category nor the phrasing category, then this is a
+                                parse error. Stop this algorithm. The end tag token
+                                is ignored. */
+                                $this->ignored = true;
+                                break;
+                                // parse error
+                            }
+                        }
+                        /* Set node to the previous entry in the stack of open elements. Loop. */
+                    }
+                break;
+            }
+            break;
+        }
+        break;
+
+    case self::IN_CDATA_RCDATA:
+        if (
+            $token['type'] === HTML5_Tokenizer::CHARACTER ||
+            $token['type'] === HTML5_Tokenizer::SPACECHARACTER
+        ) {
+            $this->insertText($token['data']);
+        } elseif ($token['type'] === HTML5_Tokenizer::EOF) {
+            // parse error
+            /* If the current node is a script  element, mark the script
+             * element as "already executed". */
+            // probably not necessary
+            array_pop($this->stack);
+            $this->mode = $this->original_mode;
+            $this->emitToken($token);
+        } elseif ($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'script') {
+            array_pop($this->stack);
+            $this->mode = $this->original_mode;
+            // we're ignoring all of the execution stuff
+        } elseif ($token['type'] === HTML5_Tokenizer::ENDTAG) {
+            array_pop($this->stack);
+            $this->mode = $this->original_mode;
+        }
+    break;
+
+    case self::IN_TABLE:
+        $clear = array('html', 'table');
+
+        /* A character token */
+        if ($token['type'] === HTML5_Tokenizer::CHARACTER ||
+            $token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Let the pending table character tokens
+             * be an empty list of tokens. */
+            $this->pendingTableCharacters = "";
+            $this->pendingTableCharactersDirty = false;
+            /* Let the original insertion mode be the current
+             * insertion mode. */
+            $this->original_mode = $this->mode;
+            /* Switch the insertion mode to
+             * "in table text" and
+             * reprocess the token. */
+            $this->mode = self::IN_TABLE_TEXT;
+            $this->emitToken($token);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data
+            attribute set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        /* A start tag whose tag name is "caption" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'caption') {
+            /* Clear the stack back to a table context. */
+            $this->clearStackToTableContext($clear);
+
+            /* Insert a marker at the end of the list of active
+            formatting elements. */
+            $this->a_formatting[] = self::MARKER;
+
+            /* Insert an HTML element for the token, then switch the
+            insertion mode to "in caption". */
+            $this->insertElement($token);
+            $this->mode = self::IN_CAPTION;
+
+        /* A start tag whose tag name is "colgroup" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'colgroup') {
+            /* Clear the stack back to a table context. */
+            $this->clearStackToTableContext($clear);
+
+            /* Insert an HTML element for the token, then switch the
+            insertion mode to "in column group". */
+            $this->insertElement($token);
+            $this->mode = self::IN_COLUMN_GROUP;
+
+        /* A start tag whose tag name is "col" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'col') {
+            $this->emitToken(array(
+                'name' => 'colgroup',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+
+            $this->emitToken($token);
+
+        /* A start tag whose tag name is one of: "tbody", "tfoot", "thead" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('tbody', 'tfoot', 'thead'))) {
+            /* Clear the stack back to a table context. */
+            $this->clearStackToTableContext($clear);
+
+            /* Insert an HTML element for the token, then switch the insertion
+            mode to "in table body". */
+            $this->insertElement($token);
+            $this->mode = self::IN_TABLE_BODY;
+
+        /* A start tag whose tag name is one of: "td", "th", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        in_array($token['name'], array('td', 'th', 'tr'))) {
+            /* Act as if a start tag token with the tag name "tbody" had been
+            seen, then reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'tbody',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+
+            $this->emitToken($token);
+
+        /* A start tag whose tag name is "table" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'table') {
+            /* Parse error. Act as if an end tag token with the tag name "table"
+            had been seen, then, if that token wasn't ignored, reprocess the
+            current token. */
+            $this->emitToken(array(
+                'name' => 'table',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+
+            if (!$this->ignored) $this->emitToken($token);
+
+        /* An end tag whose tag name is "table" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'table') {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. (fragment case) */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                do {
+                    $node = array_pop($this->stack);
+                } while ($node->tagName !== 'table');
+
+                /* Reset the insertion mode appropriately. */
+                $this->resetInsertionMode();
+            }
+
+        /* An end tag whose tag name is one of: "body", "caption", "col",
+        "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('body', 'caption', 'col', 'colgroup', 'html', 'tbody', 'td',
+        'tfoot', 'th', 'thead', 'tr'))) {
+            // Parse error. Ignore the token.
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'style' || $token['name'] === 'script')) {
+            $this->processWithRulesFor($token, self::IN_HEAD);
+
+        } elseif ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'input' &&
+        // assignment is intentional
+        /* If the token does not have an attribute with the name "type", or
+         * if it does, but that attribute's value is not an ASCII
+         * case-insensitive match for the string "hidden", then: act as
+         * described in the "anything else" entry below. */
+        ($type = $this->getAttr($token, 'type')) && strtolower($type) === 'hidden') {
+            // I.e., if its an input with the type attribute == 'hidden'
+            /* Otherwise */
+            // parse error
+            $this->insertElement($token);
+            array_pop($this->stack);
+        } elseif ($token['type'] === HTML5_Tokenizer::EOF) {
+            /* If the current node is not the root html element, then this is a parse error. */
+            if (end($this->stack)->tagName !== 'html') {
+                // Note: It can only be the current node in the fragment case.
+                // parse error
+            }
+            /* Stop parsing. */
+        /* Anything else */
+        } else {
+            /* Parse error. Process the token as if the insertion mode was "in
+            body", with the following exception: */
+
+            $old = $this->foster_parent;
+            $this->foster_parent = true;
+            $this->processWithRulesFor($token, self::IN_BODY);
+            $this->foster_parent = $old;
+        }
+    break;
+
+    case self::IN_TABLE_TEXT:
+        /* A character token */
+        if($token['type'] === HTML5_Tokenizer::CHARACTER) {
+            /* Append the character token to the pending table
+             * character tokens list. */
+            $this->pendingTableCharacters .= $token['data'];
+            $this->pendingTableCharactersDirty = true;
+        } elseif ($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            $this->pendingTableCharacters .= $token['data'];
+        /* Anything else */
+        } else {
+            if ($this->pendingTableCharacters !== '' && is_string($this->pendingTableCharacters)) {
+                /* If any of the tokens in the pending table character tokens list 
+                 * are character tokens that are not one of U+0009 CHARACTER 
+                 * TABULATION, U+000A LINE FEED (LF), U+000C FORM FEED (FF), or 
+                 * U+0020 SPACE, then reprocess those character tokens using the 
+                 * rules given in the "anything else" entry in the in table" 
+                 * insertion mode.*/
+                if ($this->pendingTableCharactersDirty) {
+                    /* Parse error. Process the token using the rules for the 
+                     * "in body" insertion mode, except that if the current 
+                     * node is a table, tbody, tfoot, thead, or tr element, 
+                     * then, whenever a node would be inserted into the current 
+                     * node, it must instead be foster parented. */
+                    // XERROR
+                    $old = $this->foster_parent;
+                    $this->foster_parent = true;
+                    $text_token = array(
+                        'type' => HTML5_Tokenizer::CHARACTER,
+                        'data' => $this->pendingTableCharacters,
+                    );
+                    $this->processWithRulesFor($text_token, self::IN_BODY);
+                    $this->foster_parent = $old;
+
+                /* Otherwise, insert the characters given by the pending table 
+                 * character tokens list into the current node. */
+                } else {
+                    $this->insertText($this->pendingTableCharacters);
+                }
+                $this->pendingTableCharacters = null;
+                $this->pendingTableCharactersNull = null;
+            }
+
+            /* Switch the insertion mode to the original insertion mode and 
+             * reprocess the token.
+             */
+            $this->mode = $this->original_mode;
+            $this->emitToken($token);
+        }
+    break;
+
+    case self::IN_CAPTION:
+        /* An end tag whose tag name is "caption" */
+        if($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'caption') {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. (fragment case) */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->ignored = true;
+                // Ignore
+
+            /* Otherwise: */
+            } else {
+                /* Generate implied end tags. */
+                $this->generateImpliedEndTags();
+
+                /* Now, if the current node is not a caption element, then this
+                is a parse error. */
+                // XERROR: implement
+
+                /* Pop elements from this stack until a caption element has
+                been popped from the stack. */
+                do {
+                    $node = array_pop($this->stack);
+                } while ($node->tagName !== 'caption');
+
+                /* Clear the list of active formatting elements up to the last
+                marker. */
+                $this->clearTheActiveFormattingElementsUpToTheLastMarker();
+
+                /* Switch the insertion mode to "in table". */
+                $this->mode = self::IN_TABLE;
+            }
+
+        /* A start tag whose tag name is one of: "caption", "col", "colgroup",
+        "tbody", "td", "tfoot", "th", "thead", "tr", or an end tag whose tag
+        name is "table" */
+        } elseif(($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
+        'thead', 'tr'))) || ($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'table')) {
+            /* Parse error. Act as if an end tag with the tag name "caption"
+            had been seen, then, if that token wasn't ignored, reprocess the
+            current token. */
+            $this->emitToken(array(
+                'name' => 'caption',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+
+            if (!$this->ignored) $this->emitToken($token);
+
+        /* An end tag whose tag name is one of: "body", "col", "colgroup",
+        "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('body', 'col', 'colgroup', 'html', 'tbody', 'tfoot', 'th',
+        'thead', 'tr'))) {
+            // Parse error. Ignore the token.
+            $this->ignored = true;
+
+        /* Anything else */
+        } else {
+            /* Process the token as if the insertion mode was "in body". */
+            $this->processWithRulesFor($token, self::IN_BODY);
+        }
+    break;
+
+    case self::IN_COLUMN_GROUP:
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Append the character to the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data
+            attribute set to the data given in the comment token. */
+            $this->insertToken($token['data']);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* A start tag whose tag name is "col" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'col') {
+            /* Insert a col element for the token. Immediately pop the current
+            node off the stack of open elements. */
+            $this->insertElement($token);
+            array_pop($this->stack);
+            // XERROR: Acknowledge the token's self-closing flag, if it is set.
+
+        /* An end tag whose tag name is "colgroup" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'colgroup') {
+            /* If the current node is the root html element, then this is a
+            parse error, ignore the token. (fragment case) */
+            if(end($this->stack)->tagName === 'html') {
+                $this->ignored = true;
+
+            /* Otherwise, pop the current node (which will be a colgroup
+            element) from the stack of open elements. Switch the insertion
+            mode to "in table". */
+            } else {
+                array_pop($this->stack);
+                $this->mode = self::IN_TABLE;
+            }
+
+        /* An end tag whose tag name is "col" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'col') {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+
+        /* An end-of-file token */
+        /* If the current node is the root html  element */
+        } elseif($token['type'] === HTML5_Tokenizer::EOF && end($this->stack)->tagName === 'html') {
+            /* Stop parsing */
+
+        /* Anything else */
+        } else {
+            /* Act as if an end tag with the tag name "colgroup" had been seen,
+            and then, if that token wasn't ignored, reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'colgroup',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+
+            if (!$this->ignored) $this->emitToken($token);
+        }
+    break;
+
+    case self::IN_TABLE_BODY:
+        $clear = array('tbody', 'tfoot', 'thead', 'html');
+
+        /* A start tag whose tag name is "tr" */
+        if($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'tr') {
+            /* Clear the stack back to a table body context. */
+            $this->clearStackToTableContext($clear);
+
+            /* Insert a tr element for the token, then switch the insertion
+            mode to "in row". */
+            $this->insertElement($token);
+            $this->mode = self::IN_ROW;
+
+        /* A start tag whose tag name is one of: "th", "td" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'th' ||    $token['name'] === 'td')) {
+            /* Parse error. Act as if a start tag with the tag name "tr" had
+            been seen, then reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'tr',
+                'type' => HTML5_Tokenizer::STARTTAG,
+                'attr' => array()
+            ));
+
+            $this->emitToken($token);
+
+        /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                // Parse error
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                /* Clear the stack back to a table body context. */
+                $this->clearStackToTableContext($clear);
+
+                /* Pop the current node from the stack of open elements. Switch
+                the insertion mode to "in table". */
+                array_pop($this->stack);
+                $this->mode = self::IN_TABLE;
+            }
+
+        /* A start tag whose tag name is one of: "caption", "col", "colgroup",
+        "tbody", "tfoot", "thead", or an end tag whose tag name is "table" */
+        } elseif(($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('caption', 'col', 'colgroup', 'tbody', 'tfoot', 'thead'))) ||
+        ($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'table')) {
+            /* If the stack of open elements does not have a tbody, thead, or
+            tfoot element in table scope, this is a parse error. Ignore the
+            token. (fragment case) */
+            if(!$this->elementInScope(array('tbody', 'thead', 'tfoot'), self::SCOPE_TABLE)) {
+                // parse error
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                /* Clear the stack back to a table body context. */
+                $this->clearStackToTableContext($clear);
+
+                /* Act as if an end tag with the same tag name as the current
+                node ("tbody", "tfoot", or "thead") had been seen, then
+                reprocess the current token. */
+                $this->emitToken(array(
+                    'name' => end($this->stack)->tagName,
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+
+                $this->emitToken($token);
+            }
+
+        /* An end tag whose tag name is one of: "body", "caption", "col",
+        "colgroup", "html", "td", "th", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr'))) {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+
+        /* Anything else */
+        } else {
+            /* Process the token as if the insertion mode was "in table". */
+            $this->processWithRulesFor($token, self::IN_TABLE);
+        }
+    break;
+
+    case self::IN_ROW:
+        $clear = array('tr', 'html');
+
+        /* A start tag whose tag name is one of: "th", "td" */
+        if($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'th' || $token['name'] === 'td')) {
+            /* Clear the stack back to a table row context. */
+            $this->clearStackToTableContext($clear);
+
+            /* Insert an HTML element for the token, then switch the insertion
+            mode to "in cell". */
+            $this->insertElement($token);
+            $this->mode = self::IN_CELL;
+
+            /* Insert a marker at the end of the list of active formatting
+            elements. */
+            $this->a_formatting[] = self::MARKER;
+
+        /* An end tag whose tag name is "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'tr') {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. (fragment case) */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                // Ignore.
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                /* Clear the stack back to a table row context. */
+                $this->clearStackToTableContext($clear);
+
+                /* Pop the current node (which will be a tr element) from the
+                stack of open elements. Switch the insertion mode to "in table
+                body". */
+                array_pop($this->stack);
+                $this->mode = self::IN_TABLE_BODY;
+            }
+
+        /* A start tag whose tag name is one of: "caption", "col", "colgroup",
+        "tbody", "tfoot", "thead", "tr" or an end tag whose tag name is "table" */
+        } elseif(($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('caption', 'col', 'colgroup', 'tbody', 'tfoot', 'thead', 'tr'))) ||
+        ($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'table')) {
+            /* Act as if an end tag with the tag name "tr" had been seen, then,
+            if that token wasn't ignored, reprocess the current token. */
+            $this->emitToken(array(
+                'name' => 'tr',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+            if (!$this->ignored) $this->emitToken($token);
+
+        /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                /* Otherwise, act as if an end tag with the tag name "tr" had
+                been seen, then reprocess the current token. */
+                $this->emitToken(array(
+                    'name' => 'tr',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+
+                $this->emitToken($token);
+            }
+
+        /* An end tag whose tag name is one of: "body", "caption", "col",
+        "colgroup", "html", "td", "th" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th'))) {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+
+        /* Anything else */
+        } else {
+            /* Process the token as if the insertion mode was "in table". */
+            $this->processWithRulesFor($token, self::IN_TABLE);
+        }
+    break;
+
+    case self::IN_CELL:
+        /* An end tag whose tag name is one of: "td", "th" */
+        if($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        ($token['name'] === 'td' || $token['name'] === 'th')) {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as that of the token, then this is a
+            parse error and the token must be ignored. */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->ignored = true;
+
+            /* Otherwise: */
+            } else {
+                /* Generate implied end tags, except for elements with the same
+                tag name as the token. */
+                $this->generateImpliedEndTags(array($token['name']));
+
+                /* Now, if the current node is not an element with the same tag
+                name as the token, then this is a parse error. */
+                // XERROR: Implement parse error code
+
+                /* Pop elements from this stack until an element with the same
+                tag name as the token has been popped from the stack. */
+                do {
+                    $node = array_pop($this->stack);
+                } while ($node->tagName !== $token['name']);
+
+                /* Clear the list of active formatting elements up to the last
+                marker. */
+                $this->clearTheActiveFormattingElementsUpToTheLastMarker();
+
+                /* Switch the insertion mode to "in row". (The current node
+                will be a tr element at this point.) */
+                $this->mode = self::IN_ROW;
+            }
+
+        /* A start tag whose tag name is one of: "caption", "col", "colgroup",
+        "tbody", "td", "tfoot", "th", "thead", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && in_array($token['name'],
+        array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
+        'thead', 'tr'))) {
+            /* If the stack of open elements does not have a td or th element
+            in table scope, then this is a parse error; ignore the token.
+            (fragment case) */
+            if(!$this->elementInScope(array('td', 'th'), self::SCOPE_TABLE)) {
+                // parse error
+                $this->ignored = true;
+
+            /* Otherwise, close the cell (see below) and reprocess the current
+            token. */
+            } else {
+                $this->closeCell();
+                $this->emitToken($token);
+            }
+
+        /* An end tag whose tag name is one of: "body", "caption", "col",
+        "colgroup", "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('body', 'caption', 'col', 'colgroup', 'html'))) {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+
+        /* An end tag whose tag name is one of: "table", "tbody", "tfoot",
+        "thead", "tr" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && in_array($token['name'],
+        array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
+            /* If the stack of open elements does not have a td or th element
+            in table scope, then this is a parse error; ignore the token.
+            (innerHTML case) */
+            if(!$this->elementInScope(array('td', 'th'), self::SCOPE_TABLE)) {
+                // Parse error
+                $this->ignored = true;
+
+            /* Otherwise, close the cell (see below) and reprocess the current
+            token. */
+            } else {
+                $this->closeCell();
+                $this->emitToken($token);
+            }
+
+        /* Anything else */
+        } else {
+            /* Process the token as if the insertion mode was "in body". */
+            $this->processWithRulesFor($token, self::IN_BODY);
+        }
+    break;
+
+    case self::IN_SELECT:
+        /* Handle the token as follows: */
+
+        /* A character token */
+        if(
+            $token['type'] === HTML5_Tokenizer::CHARACTER ||
+            $token['type'] === HTML5_Tokenizer::SPACECHARACTER
+        ) {
+            /* Append the token's character to the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data
+            attribute set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::INBODY);
+
+        /* A start tag token whose tag name is "option" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'option') {
+            /* If the current node is an option element, act as if an end tag
+            with the tag name "option" had been seen. */
+            if(end($this->stack)->tagName === 'option') {
+                $this->emitToken(array(
+                    'name' => 'option',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+            }
+
+            /* Insert an HTML element for the token. */
+            $this->insertElement($token);
+
+        /* A start tag token whose tag name is "optgroup" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'optgroup') {
+            /* If the current node is an option element, act as if an end tag
+            with the tag name "option" had been seen. */
+            if(end($this->stack)->tagName === 'option') {
+                $this->emitToken(array(
+                    'name' => 'option',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+            }
+
+            /* If the current node is an optgroup element, act as if an end tag
+            with the tag name "optgroup" had been seen. */
+            if(end($this->stack)->tagName === 'optgroup') {
+                $this->emitToken(array(
+                    'name' => 'optgroup',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+            }
+
+            /* Insert an HTML element for the token. */
+            $this->insertElement($token);
+
+        /* An end tag token whose tag name is "optgroup" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'optgroup') {
+            /* First, if the current node is an option element, and the node
+            immediately before it in the stack of open elements is an optgroup
+            element, then act as if an end tag with the tag name "option" had
+            been seen. */
+            $elements_in_stack = count($this->stack);
+
+            if($this->stack[$elements_in_stack - 1]->tagName === 'option' &&
+            $this->stack[$elements_in_stack - 2]->tagName === 'optgroup') {
+                $this->emitToken(array(
+                    'name' => 'option',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+            }
+
+            /* If the current node is an optgroup element, then pop that node
+            from the stack of open elements. Otherwise, this is a parse error,
+            ignore the token. */
+            if(end($this->stack)->tagName === 'optgroup') {
+                array_pop($this->stack);
+            } else {
+                // parse error
+                $this->ignored = true;
+            }
+
+        /* An end tag token whose tag name is "option" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'option') {
+            /* If the current node is an option element, then pop that node
+            from the stack of open elements. Otherwise, this is a parse error,
+            ignore the token. */
+            if(end($this->stack)->tagName === 'option') {
+                array_pop($this->stack);
+            } else {
+                // parse error
+                $this->ignored = true;
+            }
+
+        /* An end tag whose tag name is "select" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'select') {
+            /* If the stack of open elements does not have an element in table
+            scope with the same tag name as the token, this is a parse error.
+            Ignore the token. (fragment case) */
+            if(!$this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->ignored = true;
+                // parse error
+
+            /* Otherwise: */
+            } else {
+                /* Pop elements from the stack of open elements until a select
+                element has been popped from the stack. */
+                do {
+                    $node = array_pop($this->stack);
+                } while ($node->tagName !== 'select');
+
+                /* Reset the insertion mode appropriately. */
+                $this->resetInsertionMode();
+            }
+
+        /* A start tag whose tag name is "select" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'select') {
+            /* Parse error. Act as if the token had been an end tag with the
+            tag name "select" instead. */
+            $this->emitToken(array(
+                'name' => 'select',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        ($token['name'] === 'input' || $token['name'] === 'keygen' ||  $token['name'] === 'textarea')) {
+            // parse error
+            $this->emitToken(array(
+                'name' => 'select',
+                'type' => HTML5_Tokenizer::ENDTAG
+            ));
+            $this->emitToken($token);
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'script') {
+            $this->processWithRulesFor($token, self::IN_HEAD);
+
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            // XERROR: If the current node is not the root html element, then this is a parse error.
+            /* Stop parsing */
+
+        /* Anything else */
+        } else {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+        }
+    break;
+
+    case self::IN_SELECT_IN_TABLE:
+
+        if($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        in_array($token['name'], array('caption', 'table', 'tbody',
+        'tfoot', 'thead', 'tr', 'td', 'th'))) {
+            // parse error
+            $this->emitToken(array(
+                'name' => 'select',
+                'type' => HTML5_Tokenizer::ENDTAG,
+            ));
+            $this->emitToken($token);
+
+        /* An end tag whose tag name is one of: "caption", "table", "tbody",
+        "tfoot", "thead", "tr", "td", "th" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        in_array($token['name'], array('caption', 'table', 'tbody', 'tfoot', 'thead', 'tr', 'td', 'th')))  {
+            /* Parse error. */
+            // parse error
+
+            /* If the stack of open elements has an element in table scope with
+            the same tag name as that of the token, then act as if an end tag
+            with the tag name "select" had been seen, and reprocess the token.
+            Otherwise, ignore the token. */
+            if($this->elementInScope($token['name'], self::SCOPE_TABLE)) {
+                $this->emitToken(array(
+                    'name' => 'select',
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+
+                $this->emitToken($token);
+            } else {
+                $this->ignored = true;
+            }
+        } else {
+            $this->processWithRulesFor($token, self::IN_SELECT);
+        }
+    break;
+
+    case self::IN_FOREIGN_CONTENT:
+        if ($token['type'] === HTML5_Tokenizer::CHARACTER ||
+        $token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            $this->insertText($token['data']);
+        } elseif ($token['type'] === HTML5_Tokenizer::COMMENT) {
+            $this->insertComment($token['data']);
+        } elseif ($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // XERROR: parse error
+        } elseif ($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'script' && end($this->stack)->tagName === 'script' &&
+        // XDOM
+        end($this->stack)->namespaceURI === self::NS_SVG) {
+            array_pop($this->stack);
+            // a bunch of script running mumbo jumbo
+        } elseif (
+            ($token['type'] === HTML5_Tokenizer::STARTTAG &&
+                ((
+                    $token['name'] !== 'mglyph' &&
+                    $token['name'] !== 'malignmark' &&
+                    // XDOM
+                    end($this->stack)->namespaceURI === self::NS_MATHML &&
+                    in_array(end($this->stack)->tagName, array('mi', 'mo', 'mn', 'ms', 'mtext'))
+                ) ||
+                (
+                    $token['name'] === 'svg' &&
+                    // XDOM
+                    end($this->stack)->namespaceURI === self::NS_MATHML &&
+                    end($this->stack)->tagName === 'annotation-xml'
+                ) ||
+                (
+                    // XDOM
+                    end($this->stack)->namespaceURI === self::NS_SVG &&
+                    in_array(end($this->stack)->tagName, array('foreignObject', 'desc', 'title'))
+                ) ||
+                (
+                    // XSKETCHY && XDOM
+                    end($this->stack)->namespaceURI === self::NS_HTML
+                ))
+            ) || $token['type'] === HTML5_Tokenizer::ENDTAG
+        ) {
+            $this->processWithRulesFor($token, $this->secondary_mode);
+            /* If, after doing so, the insertion mode is still "in foreign 
+             * content", but there is no element in scope that has a namespace 
+             * other than the HTML namespace, switch the insertion mode to the 
+             * secondary insertion mode. */
+            if ($this->mode === self::IN_FOREIGN_CONTENT) {
+                $found = false;
+                // this basically duplicates elementInScope()
+                for ($i = count($this->stack) - 1; $i >= 0; $i--) {
+                    // XDOM
+                    $node = $this->stack[$i];
+                    if ($node->namespaceURI !== self::NS_HTML) {
+                        $found = true;
+                        break;
+                    } elseif (in_array($node->tagName, array('table', 'html',
+                    'applet', 'caption', 'td', 'th', 'button', 'marquee',
+                    'object')) || ($node->tagName === 'foreignObject' &&
+                    $node->namespaceURI === self::NS_SVG)) {
+                        break;
+                    }
+                }
+                if (!$found) {
+                    $this->mode = $this->secondary_mode;
+                }
+            }
+        } elseif ($token['type'] === HTML5_Tokenizer::EOF || (
+        $token['type'] === HTML5_Tokenizer::STARTTAG &&
+        (in_array($token['name'], array('b', "big", "blockquote", "body", "br", 
+        "center", "code", "dc", "dd", "div", "dl", "ds", "dt", "em", "embed", "h1", "h2", 
+        "h3", "h4", "h5", "h6", "head", "hr", "i", "img", "li", "listing", 
+        "menu", "meta", "nobr", "ol", "p", "pre", "ruby", "s",  "small", 
+        "span", "strong", "strike",  "sub", "sup", "table", "tt", "u", "ul", 
+        "var")) || ($token['name'] === 'font' && ($this->getAttr($token, 'color') ||
+        $this->getAttr($token, 'face') || $this->getAttr($token, 'size')))))) {
+            // XERROR: parse error
+            do {
+                $node = array_pop($this->stack);
+                // XDOM
+            } while ($node->namespaceURI !== self::NS_HTML);
+            $this->stack[] = $node;
+            $this->mode = $this->secondary_mode;
+            $this->emitToken($token);
+        } elseif ($token['type'] === HTML5_Tokenizer::STARTTAG) {
+            static $svg_lookup = array(
+                'altglyph' => 'altGlyph',
+                'altglyphdef' => 'altGlyphDef',
+                'altglyphitem' => 'altGlyphItem',
+                'animatecolor' => 'animateColor',
+                'animatemotion' => 'animateMotion',
+                'animatetransform' => 'animateTransform',
+                'clippath' => 'clipPath',
+                'feblend' => 'feBlend',
+                'fecolormatrix' => 'feColorMatrix',
+                'fecomponenttransfer' => 'feComponentTransfer',
+                'fecomposite' => 'feComposite',
+                'feconvolvematrix' => 'feConvolveMatrix',
+                'fediffuselighting' => 'feDiffuseLighting',
+                'fedisplacementmap' => 'feDisplacementMap',
+                'fedistantlight' => 'feDistantLight',
+                'feflood' => 'feFlood',
+                'fefunca' => 'feFuncA',
+                'fefuncb' => 'feFuncB',
+                'fefuncg' => 'feFuncG',
+                'fefuncr' => 'feFuncR',
+                'fegaussianblur' => 'feGaussianBlur',
+                'feimage' => 'feImage',
+                'femerge' => 'feMerge',
+                'femergenode' => 'feMergeNode',
+                'femorphology' => 'feMorphology',
+                'feoffset' => 'feOffset',
+                'fepointlight' => 'fePointLight',
+                'fespecularlighting' => 'feSpecularLighting',
+                'fespotlight' => 'feSpotLight',
+                'fetile' => 'feTile',
+                'feturbulence' => 'feTurbulence',
+                'foreignobject' => 'foreignObject',
+                'glyphref' => 'glyphRef',
+                'lineargradient' => 'linearGradient',
+                'radialgradient' => 'radialGradient',
+                'textpath' => 'textPath',
+            );
+            // XDOM
+            $current = end($this->stack);
+            if ($current->namespaceURI === self::NS_MATHML) {
+                $token = $this->adjustMathMLAttributes($token);
+            }
+            if ($current->namespaceURI === self::NS_SVG &&
+            isset($svg_lookup[$token['name']])) {
+                $token['name'] = $svg_lookup[$token['name']];
+            }
+            if ($current->namespaceURI === self::NS_SVG) {
+                $token = $this->adjustSVGAttributes($token);
+            }
+            $token = $this->adjustForeignAttributes($token);
+            $this->insertForeignElement($token, $current->namespaceURI);
+            if (isset($token['self-closing'])) {
+                array_pop($this->stack);
+                // XERROR: acknowledge self-closing flag
+            }
+        }
+    break;
+
+    case self::AFTER_BODY:
+        /* Handle the token as follows: */
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Process the token as it would be processed if the insertion mode
+            was "in body". */
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the first element in the stack of open
+            elements (the html element), with the data attribute set to the
+            data given in the comment token. */
+            // XDOM
+            $comment = $this->dom->createComment($token['data']);
+            $this->stack[0]->appendChild($comment);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* An end tag with the tag name "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG && $token['name'] === 'html') {
+            /*     If the parser was originally created as part of the HTML
+             *     fragment parsing algorithm, this is a parse error; ignore
+             *     the token. (fragment case) */
+            $this->ignored = true;
+            // XERROR: implement this
+
+            $this->mode = self::AFTER_AFTER_BODY;
+
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            /* Stop parsing */
+
+        /* Anything else */
+        } else {
+            /* Parse error. Set the insertion mode to "in body" and reprocess
+            the token. */
+            $this->mode = self::IN_BODY;
+            $this->emitToken($token);
+        }
+    break;
+
+    case self::IN_FRAMESET:
+        /* Handle the token as follows: */
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Append the character to the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data
+            attribute set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        /* A start tag with the tag name "frameset" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'frameset') {
+            $this->insertElement($token);
+
+        /* An end tag with the tag name "frameset" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'frameset') {
+            /* If the current node is the root html element, then this is a
+            parse error; ignore the token. (fragment case) */
+            if(end($this->stack)->tagName === 'html') {
+                $this->ignored = true;
+                // Parse error
+
+            } else {
+                /* Otherwise, pop the current node from the stack of open
+                elements. */
+                array_pop($this->stack);
+
+                /* If the parser was not originally created as part of the HTML 
+                 * fragment parsing algorithm  (fragment case), and the current 
+                 * node is no longer a frameset element, then switch the 
+                 * insertion mode to "after frameset". */
+                $this->mode = self::AFTER_FRAMESET;
+            }
+
+        /* A start tag with the tag name "frame" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'frame') {
+            /* Insert an HTML element for the token. */
+            $this->insertElement($token);
+
+            /* Immediately pop the current node off the stack of open elements. */
+            array_pop($this->stack);
+
+            // XERROR: Acknowledge the token's self-closing flag, if it is set.
+
+        /* A start tag with the tag name "noframes" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'noframes') {
+            /* Process the token using the rules for the "in head" insertion mode. */
+            $this->processwithRulesFor($token, self::IN_HEAD);
+
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            // XERROR: If the current node is not the root html element, then this is a parse error.
+            /* Stop parsing */
+        /* Anything else */
+        } else {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+        }
+    break;
+
+    case self::AFTER_FRAMESET:
+        /* Handle the token as follows: */
+
+        /* A character token that is one of one of U+0009 CHARACTER TABULATION,
+        U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
+        U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
+        if($token['type'] === HTML5_Tokenizer::SPACECHARACTER) {
+            /* Append the character to the current node. */
+            $this->insertText($token['data']);
+
+        /* A comment token */
+        } elseif($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the current node with the data
+            attribute set to the data given in the comment token. */
+            $this->insertComment($token['data']);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE) {
+            // parse error
+
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html') {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* An end tag with the tag name "html" */
+        } elseif($token['type'] === HTML5_Tokenizer::ENDTAG &&
+        $token['name'] === 'html') {
+            $this->mode = self::AFTER_AFTER_FRAMESET;
+
+        /* A start tag with the tag name "noframes" */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG &&
+        $token['name'] === 'noframes') {
+            $this->processWithRulesFor($token, self::IN_HEAD);
+
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            /* Stop parsing */
+
+        /* Anything else */
+        } else {
+            /* Parse error. Ignore the token. */
+            $this->ignored = true;
+        }
+    break;
+
+    case self::AFTER_AFTER_BODY:
+        /* A comment token */
+        if($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the Document object with the data
+            attribute set to the data given in the comment token. */
+            // XDOM
+            $comment = $this->dom->createComment($token['data']);
+            $this->dom->appendChild($comment);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE ||
+        $token['type'] === HTML5_Tokenizer::SPACECHARACTER ||
+        ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html')) {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* An end-of-file token */
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            /* OMG DONE!! */
+        } else {
+            // parse error
+            $this->mode = self::IN_BODY;
+            $this->emitToken($token);
+        }
+    break;
+
+    case self::AFTER_AFTER_FRAMESET:
+        /* A comment token */
+        if($token['type'] === HTML5_Tokenizer::COMMENT) {
+            /* Append a Comment node to the Document object with the data
+            attribute set to the data given in the comment token. */
+            // XDOM
+            $comment = $this->dom->createComment($token['data']);
+            $this->dom->appendChild($comment);
+
+        } elseif($token['type'] === HTML5_Tokenizer::DOCTYPE ||
+        $token['type'] === HTML5_Tokenizer::SPACECHARACTER ||
+        ($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'html')) {
+            $this->processWithRulesFor($token, self::IN_BODY);
+
+        /* An end-of-file token */
+        } elseif($token['type'] === HTML5_Tokenizer::EOF) {
+            /* OMG DONE!! */
+        } elseif($token['type'] === HTML5_Tokenizer::STARTTAG && $token['name'] === 'nofrmaes') {
+            $this->processWithRulesFor($token, self::IN_HEAD);
+        } else {
+            // parse error
+        }
+    break;
+    }
+        // end funky indenting
+        }
+
+    private function insertElement($token, $append = true) {
+        $el = $this->dom->createElementNS(self::NS_HTML, $token['name']);
+
+        if (!empty($token['attr'])) {
+            foreach($token['attr'] as $attr) {
+                if(!$el->hasAttribute($attr['name'])) {
+                    $el->setAttribute($attr['name'], $attr['value']);
+                }
+            }
+        }
+        if ($append) {
+            $this->appendToRealParent($el);
+            $this->stack[] = $el;
+        }
+
+        return $el;
+    }
+
+    private function insertText($data) {
+        if ($data === '') return;
+        if ($this->ignore_lf_token) {
+            if ($data[0] === "\n") {
+                $data = substr($data, 1);
+                if ($data === false) return;
+            }
+        }
+        $text = $this->dom->createTextNode($data);
+        $this->appendToRealParent($text);
+    }
+
+    private function insertComment($data) {
+        $comment = $this->dom->createComment($data);
+        $this->appendToRealParent($comment);
+    }
+
+    private function appendToRealParent($node) {
+        // this is only for the foster_parent case
+        /* If the current node is a table, tbody, tfoot, thead, or tr
+        element, then, whenever a node would be inserted into the current
+        node, it must instead be inserted into the foster parent element. */
+        if(!$this->foster_parent || !in_array(end($this->stack)->tagName,
+        array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
+            end($this->stack)->appendChild($node);
+        } else {
+            $this->fosterParent($node);
+        }
+    }
+
+    private function elementInScope($el, $scope = self::SCOPE) {
+        if(is_array($el)) {
+            foreach($el as $element) {
+                if($this->elementInScope($element, $scope)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        $leng = count($this->stack);
+
+        for($n = 0; $n < $leng; $n++) {
+            /* 1. Initialise node to be the current node (the bottommost node of
+            the stack). */
+            $node = $this->stack[$leng - 1 - $n];
+
+            if($node->tagName === $el) {
+                /* 2. If node is the target node, terminate in a match state. */
+                return true;
+
+                // We've expanded the logic for these states a little differently;
+                // Hixie's refactoring into "specific scope" is more general, but
+                // this "gets the job done"
+
+            // these are the common states for all scopes
+            } elseif($node->tagName === 'table' || $node->tagName === 'html') {
+                return false;
+
+            // these are valid for "in scope" and "in list item scope"
+            } elseif($scope !== self::SCOPE_TABLE &&
+            (in_array($node->tagName, array('applet', 'caption', 'td',
+                'th', 'button', 'marquee', 'object')) ||
+                $node->tagName === 'foreignObject' && $node->namespaceURI === self::NS_SVG)) {
+                return false;
+
+
+            // these are valid for "in list item scope"
+            } elseif($scope === self::SCOPE_LISTITEM && in_array($node->tagName, array('ol', 'ul'))) {
+                return false;
+            }
+
+            /* Otherwise, set node to the previous entry in the stack of open
+            elements and return to step 2. (This will never fail, since the loop
+            will always terminate in the previous step if the top of the stack
+            is reached.) */
+        }
+    }
+
+    private function reconstructActiveFormattingElements() {
+        /* 1. If there are no entries in the list of active formatting elements,
+        then there is nothing to reconstruct; stop this algorithm. */
+        $formatting_elements = count($this->a_formatting);
+
+        if($formatting_elements === 0) {
+            return false;
+        }
+
+        /* 3. Let entry be the last (most recently added) element in the list
+        of active formatting elements. */
+        $entry = end($this->a_formatting);
+
+        /* 2. If the last (most recently added) entry in the list of active
+        formatting elements is a marker, or if it is an element that is in the
+        stack of open elements, then there is nothing to reconstruct; stop this
+        algorithm. */
+        if($entry === self::MARKER || in_array($entry, $this->stack, true)) {
+            return false;
+        }
+
+        for($a = $formatting_elements - 1; $a >= 0; true) {
+            /* 4. If there are no entries before entry in the list of active
+            formatting elements, then jump to step 8. */
+            if($a === 0) {
+                $step_seven = false;
+                break;
+            }
+
+            /* 5. Let entry be the entry one earlier than entry in the list of
+            active formatting elements. */
+            $a--;
+            $entry = $this->a_formatting[$a];
+
+            /* 6. If entry is neither a marker nor an element that is also in
+            thetack of open elements, go to step 4. */
+            if($entry === self::MARKER || in_array($entry, $this->stack, true)) {
+                break;
+            }
+        }
+
+        while(true) {
+            /* 7. Let entry be the element one later than entry in the list of
+            active formatting elements. */
+            if(isset($step_seven) && $step_seven === true) {
+                $a++;
+                $entry = $this->a_formatting[$a];
+            }
+
+            /* 8. Perform a shallow clone of the element entry to obtain clone. */
+            $clone = $entry->cloneNode();
+
+            /* 9. Append clone to the current node and push it onto the stack
+            of open elements  so that it is the new current node. */
+            $this->appendToRealParent($clone);
+            $this->stack[] = $clone;
+
+            /* 10. Replace the entry for entry in the list with an entry for
+            clone. */
+            $this->a_formatting[$a] = $clone;
+
+            /* 11. If the entry for clone in the list of active formatting
+            elements is not the last entry in the list, return to step 7. */
+            if(end($this->a_formatting) !== $clone) {
+                $step_seven = true;
+            } else {
+                break;
+            }
+        }
+    }
+
+    private function clearTheActiveFormattingElementsUpToTheLastMarker() {
+        /* When the steps below require the UA to clear the list of active
+        formatting elements up to the last marker, the UA must perform the
+        following steps: */
+
+        while(true) {
+            /* 1. Let entry be the last (most recently added) entry in the list
+            of active formatting elements. */
+            $entry = end($this->a_formatting);
+
+            /* 2. Remove entry from the list of active formatting elements. */
+            array_pop($this->a_formatting);
+
+            /* 3. If entry was a marker, then stop the algorithm at this point.
+            The list has been cleared up to the last marker. */
+            if($entry === self::MARKER) {
+                break;
+            }
+        }
+    }
+
+    private function generateImpliedEndTags($exclude = array()) {
+        /* When the steps below require the UA to generate implied end tags, 
+         * then, while the current node is a dc element, a dd element, a ds 
+         * element, a dt element, an li element, an option element, an optgroup 
+         * element, a p element, an rp element, or an rt element, the UA must 
+         * pop the current node off the stack of open elements. */
+        $node = end($this->stack);
+        $elements = array_diff(array('dc', 'dd', 'ds', 'dt', 'li', 'p', 'td', 'th', 'tr'), $exclude);
+
+        while(in_array(end($this->stack)->tagName, $elements)) {
+            array_pop($this->stack);
+        }
+    }
+
+    private function getElementCategory($node) {
+        if (!is_object($node)) debug_print_backtrace();
+        $name = $node->tagName;
+        if(in_array($name, $this->special))
+            return self::SPECIAL;
+
+        elseif(in_array($name, $this->scoping))
+            return self::SCOPING;
+
+        elseif(in_array($name, $this->formatting))
+            return self::FORMATTING;
+
+        else
+            return self::PHRASING;
+    }
+
+    private function clearStackToTableContext($elements) {
+        /* When the steps above require the UA to clear the stack back to a
+        table context, it means that the UA must, while the current node is not
+        a table element or an html element, pop elements from the stack of open
+        elements. */
+        while(true) {
+            $name = end($this->stack)->tagName;
+
+            if(in_array($name, $elements)) {
+                break;
+            } else {
+                array_pop($this->stack);
+            }
+        }
+    }
+
+    private function resetInsertionMode($context = null) {
+        /* 1. Let last be false. */
+        $last = false;
+        $leng = count($this->stack);
+
+        for($n = $leng - 1; $n >= 0; $n--) {
+            /* 2. Let node be the last node in the stack of open elements. */
+            $node = $this->stack[$n];
+
+            /* 3. If node is the first node in the stack of open elements, then 
+             * set last to true and set node to the context  element. (fragment 
+             * case) */
+            if($this->stack[0]->isSameNode($node)) {
+                $last = true;
+                $node = $context;
+            }
+
+            /* 4. If node is a select element, then switch the insertion mode to
+            "in select" and abort these steps. (fragment case) */
+            if($node->tagName === 'select') {
+                $this->mode = self::IN_SELECT;
+                break;
+
+            /* 5. If node is a td or th element, then switch the insertion mode
+            to "in cell" and abort these steps. */
+            } elseif($node->tagName === 'td' || $node->nodeName === 'th') {
+                $this->mode = self::IN_CELL;
+                break;
+
+            /* 6. If node is a tr element, then switch the insertion mode to
+            "in    row" and abort these steps. */
+            } elseif($node->tagName === 'tr') {
+                $this->mode = self::IN_ROW;
+                break;
+
+            /* 7. If node is a tbody, thead, or tfoot element, then switch the
+            insertion mode to "in table body" and abort these steps. */
+            } elseif(in_array($node->tagName, array('tbody', 'thead', 'tfoot'))) {
+                $this->mode = self::IN_TABLE_BODY;
+                break;
+
+            /* 8. If node is a caption element, then switch the insertion mode
+            to "in caption" and abort these steps. */
+            } elseif($node->tagName === 'caption') {
+                $this->mode = self::IN_CAPTION;
+                break;
+
+            /* 9. If node is a colgroup element, then switch the insertion mode
+            to "in column group" and abort these steps. (innerHTML case) */
+            } elseif($node->tagName === 'colgroup') {
+                $this->mode = self::IN_COLUMN_GROUP;
+                break;
+
+            /* 10. If node is a table element, then switch the insertion mode
+            to "in table" and abort these steps. */
+            } elseif($node->tagName === 'table') {
+                $this->mode = self::IN_TABLE;
+                break;
+
+            /* 11. If node is an element from the MathML namespace or the SVG 
+             * namespace, then switch the insertion mode to "in foreign 
+             * content", let the secondary insertion mode be "in body", and 
+             * abort these steps. */
+            } elseif($node->namespaceURI === self::NS_SVG ||
+            $node->namespaceURI === self::NS_MATHML) {
+                $this->mode = self::IN_FOREIGN_CONTENT;
+                $this->secondary_mode = self::IN_BODY;
+                break;
+
+            /* 12. If node is a head element, then switch the insertion mode
+            to "in body" ("in body"! not "in head"!) and abort these steps.
+            (fragment case) */
+            } elseif($node->tagName === 'head') {
+                $this->mode = self::IN_BODY;
+                break;
+
+            /* 13. If node is a body element, then switch the insertion mode to
+            "in body" and abort these steps. */
+            } elseif($node->tagName === 'body') {
+                $this->mode = self::IN_BODY;
+                break;
+
+            /* 14. If node is a frameset element, then switch the insertion
+            mode to "in frameset" and abort these steps. (fragment case) */
+            } elseif($node->tagName === 'frameset') {
+                $this->mode = self::IN_FRAMESET;
+                break;
+
+            /* 15. If node is an html element, then: if the head element
+            pointer is null, switch the insertion mode to "before head",
+            otherwise, switch the insertion mode to "after head". In either
+            case, abort these steps. (fragment case) */
+            } elseif($node->tagName === 'html') {
+                $this->mode = ($this->head_pointer === null)
+                    ? self::BEFORE_HEAD
+                    : self::AFTER_HEAD;
+
+                break;
+
+            /* 16. If last is true, then set the insertion mode to "in body"
+            and    abort these steps. (fragment case) */
+            } elseif($last) {
+                $this->mode = self::IN_BODY;
+                break;
+            }
+        }
+    }
+
+    private function closeCell() {
+        /* If the stack of open elements has a td or th element in table scope,
+        then act as if an end tag token with that tag name had been seen. */
+        foreach(array('td', 'th') as $cell) {
+            if($this->elementInScope($cell, self::SCOPE_TABLE)) {
+                $this->emitToken(array(
+                    'name' => $cell,
+                    'type' => HTML5_Tokenizer::ENDTAG
+                ));
+
+                break;
+            }
+        }
+    }
+
+    private function processWithRulesFor($token, $mode) {
+        /* "using the rules for the m insertion mode", where m is one of these
+         * modes, the user agent must use the rules described under the m
+         * insertion mode's section, but must leave the insertion mode
+         * unchanged unless the rules in m themselves switch the insertion mode
+         * to a new value. */
+        return $this->emitToken($token, $mode);
+    }
+
+    private function insertCDATAElement($token) {
+        $this->insertElement($token);
+        $this->original_mode = $this->mode;
+        $this->mode = self::IN_CDATA_RCDATA;
+        $this->content_model = HTML5_Tokenizer::CDATA;
+    }
+
+    private function insertRCDATAElement($token) {
+        $this->insertElement($token);
+        $this->original_mode = $this->mode;
+        $this->mode = self::IN_CDATA_RCDATA;
+        $this->content_model = HTML5_Tokenizer::RCDATA;
+    }
+
+    private function getAttr($token, $key) {
+        if (!isset($token['attr'])) return false;
+        $ret = false;
+        foreach ($token['attr'] as $keypair) {
+            if ($keypair['name'] === $key) $ret = $keypair['value'];
+        }
+        return $ret;
+    }
+
+    private function getCurrentTable() {
+        /* The current table is the last table  element in the stack of open 
+         * elements, if there is one. If there is no table element in the stack 
+         * of open elements (fragment case), then the current table is the 
+         * first element in the stack of open elements (the html element). */
+        for ($i = count($this->stack) - 1; $i >= 0; $i--) {
+            if ($this->stack[$i]->tagName === 'table') {
+                return $this->stack[$i];
+            }
+        }
+        return $this->stack[0];
+    }
+
+    private function getFosterParent() {
+        /* The foster parent element is the parent element of the last
+        table element in the stack of open elements, if there is a
+        table element and it has such a parent element. If there is no
+        table element in the stack of open elements (innerHTML case),
+        then the foster parent element is the first element in the
+        stack of open elements (the html  element). Otherwise, if there
+        is a table element in the stack of open elements, but the last
+        table element in the stack of open elements has no parent, or
+        its parent node is not an element, then the foster parent
+        element is the element before the last table element in the
+        stack of open elements. */
+        for($n = count($this->stack) - 1; $n >= 0; $n--) {
+            if($this->stack[$n]->tagName === 'table') {
+                $table = $this->stack[$n];
+                break;
+            }
+        }
+
+        if(isset($table) && $table->parentNode !== null) {
+            return $table->parentNode;
+
+        } elseif(!isset($table)) {
+            return $this->stack[0];
+
+        } elseif(isset($table) && ($table->parentNode === null ||
+        $table->parentNode->nodeType !== XML_ELEMENT_NODE)) {
+            return $this->stack[$n - 1];
+        }
+    }
+
+    public function fosterParent($node) {
+        $foster_parent = $this->getFosterParent();
+        $table = $this->getCurrentTable(); // almost equivalent to last table element, except it can be html
+        /* When a node node is to be foster parented, the node node must be
+         * be inserted into the foster parent element. */
+        /* If the foster parent element is the parent element of the last table 
+         * element in the stack of open elements, then node must be inserted 
+         * immediately before the last table element in the stack of open 
+         * elements in the foster parent element; otherwise, node must be 
+         * appended to the foster parent element. */
+        if ($table->tagName === 'table' && $table->parentNode->isSameNode($foster_parent)) {
+            $foster_parent->insertBefore($node, $table);
+        } else {
+            $foster_parent->appendChild($node);
+        }
+    }
+
+    /**
+     * For debugging, prints the stack
+     */
+    private function printStack() {
+        $names = array();
+        foreach ($this->stack as $i => $element) {
+            $names[] = $element->tagName;
+        }
+        echo "  -> stack [" . implode(', ', $names) . "]\n";
+    }
+
+    /**
+     * For debugging, prints active formatting elements
+     */
+    private function printActiveFormattingElements() {
+        if (!$this->a_formatting) return;
+        $names = array();
+        foreach ($this->a_formatting as $node) {
+            if ($node === self::MARKER) $names[] = 'MARKER';
+            else $names[] = $node->tagName;
+        }
+        echo "  -> active formatting [" . implode(', ', $names) . "]\n";
+    }
+
+    public function currentTableIsTainted() {
+        return !empty($this->getCurrentTable()->tainted);
+    }
+
+    /**
+     * Sets up the tree constructor for building a fragment.
+     */
+    public function setupContext($context = null) {
+        $this->fragment = true;
+        if ($context) {
+            $context = $this->dom->createElementNS(self::NS_HTML, $context);
+            /* 4.1. Set the HTML parser's tokenization  stage's content model
+             * flag according to the context element, as follows: */
+            switch ($context->tagName) {
+            case 'title': case 'textarea':
+                $this->content_model = HTML5_Tokenizer::RCDATA;
+                break;
+            case 'style': case 'script': case 'xmp': case 'iframe':
+            case 'noembed': case 'noframes':
+                $this->content_model = HTML5_Tokenizer::CDATA;
+                break;
+            case 'noscript':
+                // XSCRIPT: assuming scripting is enabled
+                $this->content_model = HTML5_Tokenizer::CDATA;
+                break;
+            case 'plaintext':
+                $this->content_model = HTML5_Tokenizer::PLAINTEXT;
+                break;
+            }
+            /* 4.2. Let root be a new html element with no attributes. */
+            $root = $this->dom->createElementNS(self::NS_HTML, 'html');
+            $this->root = $root;
+            /* 4.3 Append the element root to the Document node created above. */
+            $this->dom->appendChild($root);
+            /* 4.4 Set up the parser's stack of open elements so that it 
+             * contains just the single element root. */
+            $this->stack = array($root);
+            /* 4.5 Reset the parser's insertion mode appropriately. */
+            $this->resetInsertionMode($context);
+            /* 4.6 Set the parser's form element pointer  to the nearest node 
+             * to the context element that is a form element (going straight up 
+             * the ancestor chain, and including the element itself, if it is a 
+             * form element), or, if there is no such form element, to null. */
+            $node = $context;
+            do {
+                if ($node->tagName === 'form') {
+                    $this->form_pointer = $node;
+                    break;
+                }
+            } while ($node = $node->parentNode);
+        }
+    }
+
+    public function adjustMathMLAttributes($token) {
+        foreach ($token['attr'] as &$kp) {
+            if ($kp['name'] === 'definitionurl') {
+                $kp['name'] = 'definitionURL';
+            }
+        }
+        return $token;
+    }
+
+    public function adjustSVGAttributes($token) {
+        static $lookup = array(
+            'attributename' => 'attributeName',
+            'attributetype' => 'attributeType',
+            'basefrequency' => 'baseFrequency',
+            'baseprofile' => 'baseProfile',
+            'calcmode' => 'calcMode',
+            'clippathunits' => 'clipPathUnits',
+            'contentscripttype' => 'contentScriptType',
+            'contentstyletype' => 'contentStyleType',
+            'diffuseconstant' => 'diffuseConstant',
+            'edgemode' => 'edgeMode',
+            'externalresourcesrequired' => 'externalResourcesRequired',
+            'filterres' => 'filterRes',
+            'filterunits' => 'filterUnits',
+            'glyphref' => 'glyphRef',
+            'gradienttransform' => 'gradientTransform',
+            'gradientunits' => 'gradientUnits',
+            'kernelmatrix' => 'kernelMatrix',
+            'kernelunitlength' => 'kernelUnitLength',
+            'keypoints' => 'keyPoints',
+            'keysplines' => 'keySplines',
+            'keytimes' => 'keyTimes',
+            'lengthadjust' => 'lengthAdjust',
+            'limitingconeangle' => 'limitingConeAngle',
+            'markerheight' => 'markerHeight',
+            'markerunits' => 'markerUnits',
+            'markerwidth' => 'markerWidth',
+            'maskcontentunits' => 'maskContentUnits',
+            'maskunits' => 'maskUnits',
+            'numoctaves' => 'numOctaves',
+            'pathlength' => 'pathLength',
+            'patterncontentunits' => 'patternContentUnits',
+            'patterntransform' => 'patternTransform',
+            'patternunits' => 'patternUnits',
+            'pointsatx' => 'pointsAtX',
+            'pointsaty' => 'pointsAtY',
+            'pointsatz' => 'pointsAtZ',
+            'preservealpha' => 'preserveAlpha',
+            'preserveaspectratio' => 'preserveAspectRatio',
+            'primitiveunits' => 'primitiveUnits',
+            'refx' => 'refX',
+            'refy' => 'refY',
+            'repeatcount' => 'repeatCount',
+            'repeatdur' => 'repeatDur',
+            'requiredextensions' => 'requiredExtensions',
+            'requiredfeatures' => 'requiredFeatures',
+            'specularconstant' => 'specularConstant',
+            'specularexponent' => 'specularExponent',
+            'spreadmethod' => 'spreadMethod',
+            'startoffset' => 'startOffset',
+            'stddeviation' => 'stdDeviation',
+            'stitchtiles' => 'stitchTiles',
+            'surfacescale' => 'surfaceScale',
+            'systemlanguage' => 'systemLanguage',
+            'tablevalues' => 'tableValues',
+            'targetx' => 'targetX',
+            'targety' => 'targetY',
+            'textlength' => 'textLength',
+            'viewbox' => 'viewBox',
+            'viewtarget' => 'viewTarget',
+            'xchannelselector' => 'xChannelSelector',
+            'ychannelselector' => 'yChannelSelector',
+            'zoomandpan' => 'zoomAndPan',
+        );
+        foreach ($token['attr'] as &$kp) {
+            if (isset($lookup[$kp['name']])) {
+                $kp['name'] = $lookup[$kp['name']];
+            }
+        }
+        return $token;
+    }
+
+    public function adjustForeignAttributes($token) {
+        static $lookup = array(
+            'xlink:actuate' => array('xlink', 'actuate', self::NS_XLINK),
+            'xlink:arcrole' => array('xlink', 'arcrole', self::NS_XLINK),
+            'xlink:href' => array('xlink', 'href', self::NS_XLINK),
+            'xlink:role' => array('xlink', 'role', self::NS_XLINK),
+            'xlink:show' => array('xlink', 'show', self::NS_XLINK),
+            'xlink:title' => array('xlink', 'title', self::NS_XLINK),
+            'xlink:type' => array('xlink', 'type', self::NS_XLINK),
+            'xml:base' => array('xml', 'base', self::NS_XML),
+            'xml:lang' => array('xml', 'lang', self::NS_XML),
+            'xml:space' => array('xml', 'space', self::NS_XML),
+            'xmlns' => array(null, 'xmlns', self::NS_XMLNS),
+            'xmlns:xlink' => array('xmlns', 'xlink', self::NS_XMLNS),
+        );
+        foreach ($token['attr'] as &$kp) {
+            if (isset($lookup[$kp['name']])) {
+                $kp['name'] = $lookup[$kp['name']];
+            }
+        }
+        return $token;
+    }
+
+    public function insertForeignElement($token, $namespaceURI) {
+        $el = $this->dom->createElementNS($namespaceURI, $token['name']);
+        if (!empty($token['attr'])) {
+            foreach ($token['attr'] as $kp) {
+                $attr = $kp['name'];
+                if (is_array($attr)) {
+                    $ns = $attr[2];
+                    $attr = $attr[1];
+                } else {
+                    $ns = self::NS_HTML;
+                }
+                if (!$el->hasAttributeNS($ns, $attr)) {
+                    // XSKETCHY: work around godawful libxml bug
+                    if ($ns === self::NS_XLINK) {
+                        $el->setAttribute('xlink:'.$attr, $kp['value']);
+                    } elseif ($ns === self::NS_HTML) {
+                        // Another godawful libxml bug
+                        $el->setAttribute($attr, $kp['value']);
+                    } else {
+                        $el->setAttributeNS($ns, $attr, $kp['value']);
+                    }
+                }
+            }
+        }
+        $this->appendToRealParent($el);
+        $this->stack[] = $el;
+        // XERROR: see below
+        /* If the newly created element has an xmlns attribute in the XMLNS 
+         * namespace  whose value is not exactly the same as the element's 
+         * namespace, that is a parse error. Similarly, if the newly created 
+         * element has an xmlns:xlink attribute in the XMLNS namespace whose 
+         * value is not the XLink Namespace, that is a parse error. */
+    }
+
+    public function save() {
+        $this->dom->normalize();
+        if (!$this->fragment) {
+            return $this->dom;
+        } else {
+            if ($this->root) {
+                return $this->root->childNodes;
+            } else {
+                return $this->dom->childNodes;
+            }
+        }
+    }
+}
+
diff --git a/inc/3rdparty/libraries/html5/named-character-references.ser b/inc/3rdparty/libraries/html5/named-character-references.ser
new file mode 100644
index 00000000..e3ae0502
--- /dev/null
+++ b/inc/3rdparty/libraries/html5/named-character-references.ser
@@ -0,0 +1 @@
+a:52:{s:1:"A";a:16:{s:1:"E";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:198;}s:9:"codepoint";i:198;}}}}s:1:"M";a:1:{s:1:"P";a:2:{s:1:";";a:1:{s:9:"codepoint";i:38;}s:9:"codepoint";i:38;}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:193;}s:9:"codepoint";i:193;}}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:258;}}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:194;}s:9:"codepoint";i:194;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1040;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120068;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:192;}s:9:"codepoint";i:192;}}}}}s:1:"l";a:1:{s:1:"p";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:913;}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:256;}}}}}s:1:"n";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10835;}}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:260;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120120;}}}}s:1:"p";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"y";a:1:{s:1:"F";a:1:{s:1:"u";a:1:{s:1:"n";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8289;}}}}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:197;}s:9:"codepoint";i:197;}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119964;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8788;}}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:195;}s:9:"codepoint";i:195;}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:196;}s:9:"codepoint";i:196;}}}}s:1:"B";a:8:{s:1:"a";a:2:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"s";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8726;}}}}}}}}s:1:"r";a:2:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10983;}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8966;}}}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1041;}}}s:1:"e";a:3:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8757;}}}}}}s:1:"r";a:1:{s:1:"n";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8492;}}}}}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:914;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120069;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120121;}}}}s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:728;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8492;}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"p";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8782;}}}}}}}s:1:"C";a:14:{s:1:"H";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1063;}}}}s:1:"O";a:1:{s:1:"P";a:1:{s:1:"Y";a:2:{s:1:";";a:1:{s:9:"codepoint";i:169;}s:9:"codepoint";i:169;}}}s:1:"a";a:3:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:262;}}}}}s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8914;}s:1:"i";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"D";a:1:{s:1:"i";a:1:{s:1:"f";a:1:{s:1:"f";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8517;}}}}}}}}}}}}}}}}}}}s:1:"y";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"y";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8493;}}}}}}}s:1:"c";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:268;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:199;}s:9:"codepoint";i:199;}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:264;}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8752;}}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:266;}}}}s:1:"e";a:2:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:184;}}}}}}s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:183;}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8493;}}}s:1:"h";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:935;}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"l";a:1:{s:1:"e";a:4:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8857;}}}}s:1:"M";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8854;}}}}}}s:1:"P";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8853;}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8855;}}}}}}}}}}}s:1:"l";a:1:{s:1:"o";a:2:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"w";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"C";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"I";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8754;}}}}}}}}}}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"C";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"l";a:1:{s:1:"y";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"Q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8221;}}}}}}}}}}}}s:1:"Q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8217;}}}}}}}}}}}}}}}s:1:"o";a:4:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8759;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10868;}}}}}s:1:"n";a:3:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8801;}}}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8751;}}}}s:1:"t";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"I";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8750;}}}}}}}}}}}}}}s:1:"p";a:2:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8450;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"d";a:1:{s:1:"u";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8720;}}}}}}}}s:1:"u";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"C";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"w";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"C";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"I";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8755;}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10799;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119966;}}}}s:1:"u";a:1:{s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8915;}s:1:"C";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8781;}}}}}}}s:1:"D";a:11:{s:1:"D";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8517;}s:1:"o";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"h";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10513;}}}}}}}}s:1:"J";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1026;}}}}s:1:"S";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1029;}}}}s:1:"Z";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1039;}}}}s:1:"a";a:3:{s:1:"g";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8225;}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8609;}}}s:1:"s";a:1:{s:1:"h";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10980;}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:270;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1044;}}}s:1:"e";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8711;}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:916;}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120071;}}}s:1:"i";a:2:{s:1:"a";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:4:{s:1:"A";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:180;}}}}}}s:1:"D";a:1:{s:1:"o";a:2:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:729;}}s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"A";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:733;}}}}}}}}}}}}s:1:"G";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:96;}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:732;}}}}}}}}}}}}}}s:1:"m";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8900;}}}}}}s:1:"f";a:1:{s:1:"f";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8518;}}}}}}}}}}}}}s:1:"o";a:4:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120123;}}}s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:168;}s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8412;}}}}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8784;}}}}}}}s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:6:{s:1:"C";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"I";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8751;}}}}}}}}}}}}}}}}s:1:"D";a:1:{s:1:"o";a:2:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:168;}}s:1:"w";a:1:{s:1:"n";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8659;}}}}}}}}}}s:1:"L";a:2:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:3:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8656;}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8660;}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10980;}}}}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"g";a:2:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10232;}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10234;}}}}}}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10233;}}}}}}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8658;}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8872;}}}}}}}}}s:1:"U";a:1:{s:1:"p";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8657;}}}}}}s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8661;}}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8741;}}}}}}}}}}}}}}}}s:1:"w";a:1:{s:1:"n";a:6:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8595;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10515;}}}}s:1:"U";a:1:{s:1:"p";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8693;}}}}}}}}}}}}}s:1:"B";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:785;}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:3:{s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10576;}}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10590;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8637;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10582;}}}}}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10591;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8641;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10583;}}}}}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8868;}s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8615;}}}}}}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8659;}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119967;}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:272;}}}}}}}s:1:"E";a:16:{s:1:"N";a:1:{s:1:"G";a:1:{s:1:";";a:1:{s:9:"codepoint";i:330;}}}s:1:"T";a:1:{s:1:"H";a:2:{s:1:";";a:1:{s:9:"codepoint";i:208;}s:9:"codepoint";i:208;}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:201;}s:9:"codepoint";i:201;}}}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:282;}}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:202;}s:9:"codepoint";i:202;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1069;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:278;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120072;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:200;}s:9:"codepoint";i:200;}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8712;}}}}}}}s:1:"m";a:2:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:274;}}}}s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:2:{s:1:"S";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"S";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9723;}}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"y";a:1:{s:1:"S";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"S";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9643;}}}}}}}}}}}}}}}}}}}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:280;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120124;}}}}s:1:"p";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:917;}}}}}}}s:1:"q";a:1:{s:1:"u";a:2:{s:1:"a";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10869;}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8770;}}}}}}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"b";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8652;}}}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8496;}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10867;}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:919;}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:203;}s:9:"codepoint";i:203;}}}s:1:"x";a:2:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8707;}}}}}s:1:"p";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8519;}}}}}}}}}}}}}s:1:"F";a:5:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1060;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120073;}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"d";a:2:{s:1:"S";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"S";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9724;}}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"y";a:1:{s:1:"S";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"S";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9642;}}}}}}}}}}}}}}}}}}}}}s:1:"o";a:3:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120125;}}}s:1:"r";a:1:{s:1:"A";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8704;}}}}}s:1:"u";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8497;}}}}}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8497;}}}}}s:1:"G";a:12:{s:1:"J";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1027;}}}}s:1:"T";a:2:{s:1:";";a:1:{s:9:"codepoint";i:62;}s:9:"codepoint";i:62;}s:1:"a";a:1:{s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:2:{s:1:";";a:1:{s:9:"codepoint";i:915;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:988;}}}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:286;}}}}}}s:1:"c";a:3:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:290;}}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:284;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1043;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:288;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120074;}}}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8921;}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120126;}}}}s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:6:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8805;}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8923;}}}}}}}}}}s:1:"F";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8807;}}}}}}}}}}s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10914;}}}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8823;}}}}}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10878;}}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8819;}}}}}}}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119970;}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8811;}}}s:1:"H";a:8:{s:1:"A";a:1:{s:1:"R";a:1:{s:1:"D";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1066;}}}}}}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:711;}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:94;}}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:292;}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8460;}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"b";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8459;}}}}}}}}}}}}s:1:"o";a:2:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8461;}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"z";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"L";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9472;}}}}}}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8459;}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:294;}}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"p";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"H";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8782;}}}}}}}}}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8783;}}}}}}}}}}s:1:"I";a:14:{s:1:"E";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1045;}}}}s:1:"J";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:306;}}}}}s:1:"O";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1025;}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:205;}s:9:"codepoint";i:205;}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:206;}s:9:"codepoint";i:206;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1048;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:304;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8465;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:204;}s:9:"codepoint";i:204;}}}}}s:1:"m";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8465;}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:298;}}}s:1:"g";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"y";a:1:{s:1:"I";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8520;}}}}}}}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8658;}}}}}}}s:1:"n";a:2:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8748;}s:1:"e";a:2:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8747;}}}}}s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8898;}}}}}}}}}}}s:1:"v";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:"C";a:1:{s:1:"o";a:1:{s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8291;}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8290;}}}}}}}}}}}}}}s:1:"o";a:3:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:302;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120128;}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:921;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8464;}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:296;}}}}}}s:1:"u";a:2:{s:1:"k";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1030;}}}}s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:207;}s:9:"codepoint";i:207;}}}}s:1:"J";a:5:{s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:308;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1049;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120077;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120129;}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119973;}}}s:1:"e";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1032;}}}}}}s:1:"u";a:1:{s:1:"k";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1028;}}}}}}s:1:"K";a:7:{s:1:"H";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1061;}}}}s:1:"J";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1036;}}}}s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:922;}}}}}s:1:"c";a:2:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:310;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1050;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120078;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120130;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119974;}}}}}s:1:"L";a:11:{s:1:"J";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1033;}}}}s:1:"T";a:2:{s:1:";";a:1:{s:9:"codepoint";i:60;}s:9:"codepoint";i:60;}s:1:"a";a:5:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:313;}}}}}s:1:"m";a:1:{s:1:"b";a:1:{s:1:"d";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:923;}}}}}s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10218;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8466;}}}}}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8606;}}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:317;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:315;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1051;}}}s:1:"e";a:2:{s:1:"f";a:1:{s:1:"t";a:10:{s:1:"A";a:2:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10216;}}}}}}}}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8592;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8676;}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8646;}}}}}}}}}}}}}}}}s:1:"C";a:1:{s:1:"e";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8968;}}}}}}}}s:1:"D";a:1:{s:1:"o";a:2:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10214;}}}}}}}}}}}}s:1:"w";a:1:{s:1:"n";a:2:{s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10593;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8643;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10585;}}}}}}}}}}}}}}s:1:"F";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8970;}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8596;}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10574;}}}}}}}}}}}}s:1:"T";a:2:{s:1:"e";a:1:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8867;}s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8612;}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10586;}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8882;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10703;}}}}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8884;}}}}}}}}}}}}}}s:1:"U";a:1:{s:1:"p";a:3:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10577;}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10592;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8639;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10584;}}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8636;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10578;}}}}}}}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8656;}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8660;}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"s";a:6:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8922;}}}}}}}}}}}}}s:1:"F";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8806;}}}}}}}}}}s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8822;}}}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10913;}}}}}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10877;}}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8818;}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120079;}}}s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8920;}s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8666;}}}}}}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:319;}}}}}}s:1:"o";a:3:{s:1:"n";a:1:{s:1:"g";a:4:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10229;}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10231;}}}}}}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10230;}}}}}}}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10232;}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10234;}}}}}}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10233;}}}}}}}}}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120131;}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"r";a:2:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8601;}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8600;}}}}}}}}}}}}}}}s:1:"s";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8466;}}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8624;}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:321;}}}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8810;}}}s:1:"M";a:8:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10501;}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1052;}}}s:1:"e";a:2:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8287;}}}}}}}}}}s:1:"l";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8499;}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120080;}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:"P";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8723;}}}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120132;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8499;}}}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:924;}}}s:1:"N";a:9:{s:1:"J";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1034;}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:323;}}}}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:327;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:325;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1053;}}}s:1:"e";a:3:{s:1:"g";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"v";a:1:{s:1:"e";a:3:{s:1:"M";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8203;}}}}}}}}}}}}s:1:"T";a:1:{s:1:"h";a:1:{s:1:"i";a:2:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8203;}}}}}}}}s:1:"n";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8203;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"y";a:1:{s:1:"T";a:1:{s:1:"h";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8203;}}}}}}}}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"d";a:2:{s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8811;}}}}}}}}}}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8810;}}}}}}}}}}}}}s:1:"w";a:1:{s:1:"L";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10;}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120081;}}}s:1:"o";a:4:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8288;}}}}}}s:1:"n";a:1:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"k";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:160;}}}}}}}}}}}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8469;}}}s:1:"t";a:11:{s:1:";";a:1:{s:9:"codepoint";i:10988;}s:1:"C";a:2:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8802;}}}}}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:"C";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8813;}}}}}}}s:1:"D";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8742;}}}}}}}}}}}}}}}}}}s:1:"E";a:3:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8713;}}}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8800;}}}}}s:1:"x";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8708;}}}}}}}s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8815;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8817;}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8825;}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8821;}}}}}}}}}}}}}s:1:"L";a:1:{s:1:"e";a:2:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"T";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8938;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8940;}}}}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"s";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8814;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8816;}}}}}}s:1:"G";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8824;}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8820;}}}}}}}}}}s:1:"P";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8832;}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8928;}}}}}}}}}}}}}}}}}}}s:1:"R";a:2:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"E";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8716;}}}}}}}}}}}}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"T";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8939;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8941;}}}}}}}}}}}}}}}}}}}s:1:"S";a:2:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"S";a:1:{s:1:"u";a:2:{s:1:"b";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8930;}}}}}}}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8931;}}}}}}}}}}}}}}}}}}}s:1:"u";a:3:{s:1:"b";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8840;}}}}}}}}}}s:1:"c";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8833;}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8929;}}}}}}}}}}}}}}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8841;}}}}}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8769;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8772;}}}}}}s:1:"F";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8775;}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8777;}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8740;}}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119977;}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:209;}s:9:"codepoint";i:209;}}}}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:925;}}}s:1:"O";a:14:{s:1:"E";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:338;}}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:211;}s:9:"codepoint";i:211;}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:212;}s:9:"codepoint";i:212;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1054;}}}s:1:"d";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:336;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120082;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:210;}s:9:"codepoint";i:210;}}}}}s:1:"m";a:3:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:332;}}}}s:1:"e";a:1:{s:1:"g";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:937;}}}}s:1:"i";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:927;}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120134;}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"C";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"l";a:1:{s:1:"y";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"Q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8220;}}}}}}}}}}}}s:1:"Q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8216;}}}}}}}}}}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10836;}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119978;}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:2:{s:1:";";a:1:{s:9:"codepoint";i:216;}s:9:"codepoint";i:216;}}}}}s:1:"t";a:1:{s:1:"i";a:2:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:213;}s:9:"codepoint";i:213;}}}s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10807;}}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:214;}s:9:"codepoint";i:214;}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"r";a:2:{s:1:"B";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:175;}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9182;}}s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9140;}}}}}}}}s:1:"P";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9180;}}}}}}}}}}}}}}}}s:1:"P";a:9:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8706;}}}}}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1055;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120083;}}}s:1:"h";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:934;}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:928;}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:"M";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:177;}}}}}}}}}s:1:"o";a:2:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8460;}}}}}}}}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8473;}}}}s:1:"r";a:4:{s:1:";";a:1:{s:9:"codepoint";i:10939;}s:1:"e";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:"s";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8826;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10927;}}}}}}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8828;}}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8830;}}}}}}}}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8243;}}}}s:1:"o";a:2:{s:1:"d";a:1:{s:1:"u";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8719;}}}}}s:1:"p";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8759;}s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8733;}}}}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119979;}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:936;}}}}s:1:"Q";a:4:{s:1:"U";a:1:{s:1:"O";a:1:{s:1:"T";a:2:{s:1:";";a:1:{s:9:"codepoint";i:34;}s:9:"codepoint";i:34;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120084;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8474;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119980;}}}}}s:1:"R";a:12:{s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10512;}}}}}s:1:"E";a:1:{s:1:"G";a:2:{s:1:";";a:1:{s:9:"codepoint";i:174;}s:9:"codepoint";i:174;}}s:1:"a";a:3:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:340;}}}}}s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10219;}}}s:1:"r";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8608;}s:1:"t";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10518;}}}}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:344;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:342;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1056;}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8476;}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:2:{s:1:"E";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8715;}}}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"b";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8651;}}}}}}}}}}}}s:1:"U";a:1:{s:1:"p";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"b";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10607;}}}}}}}}}}}}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8476;}}}s:1:"h";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:929;}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:8:{s:1:"A";a:2:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10217;}}}}}}}}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8594;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8677;}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8644;}}}}}}}}}}}}}}}s:1:"C";a:1:{s:1:"e";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8969;}}}}}}}}s:1:"D";a:1:{s:1:"o";a:2:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"B";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10215;}}}}}}}}}}}}s:1:"w";a:1:{s:1:"n";a:2:{s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10589;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8642;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10581;}}}}}}}}}}}}}}s:1:"F";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8971;}}}}}}s:1:"T";a:2:{s:1:"e";a:1:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8866;}s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8614;}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10587;}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8883;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10704;}}}}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8885;}}}}}}}}}}}}}}s:1:"U";a:1:{s:1:"p";a:3:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10575;}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10588;}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8638;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10580;}}}}}}}}}}}}s:1:"V";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8640;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10579;}}}}}}}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8658;}}}}}}}}}}s:1:"o";a:2:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8477;}}}s:1:"u";a:1:{s:1:"n";a:1:{s:1:"d";a:1:{s:1:"I";a:1:{s:1:"m";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10608;}}}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8667;}}}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8475;}}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8625;}}}s:1:"u";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"D";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"y";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10740;}}}}}}}}}}}}s:1:"S";a:13:{s:1:"H";a:2:{s:1:"C";a:1:{s:1:"H";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1065;}}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1064;}}}}s:1:"O";a:1:{s:1:"F";a:1:{s:1:"T";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1068;}}}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:346;}}}}}}s:1:"c";a:5:{s:1:";";a:1:{s:9:"codepoint";i:10940;}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:352;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:350;}}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:348;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1057;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120086;}}}s:1:"h";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"t";a:4:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8595;}}}}}}}}}}s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8592;}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8594;}}}}}}}}}}}s:1:"U";a:1:{s:1:"p";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8593;}}}}}}}}}}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:931;}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"C";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8728;}}}}}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120138;}}}}s:1:"q";a:2:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8730;}}}s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:9633;}s:1:"I";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8851;}}}}}}}}}}}}}s:1:"S";a:1:{s:1:"u";a:2:{s:1:"b";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8847;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8849;}}}}}}}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8848;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8850;}}}}}}}}}}}}}}s:1:"U";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8852;}}}}}}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119982;}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8902;}}}}s:1:"u";a:4:{s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8912;}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8912;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8838;}}}}}}}}}}s:1:"c";a:2:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"s";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8827;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10928;}}}}}}s:1:"S";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8829;}}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8831;}}}}}}}}}}}s:1:"h";a:1:{s:1:"T";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8715;}}}}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8721;}}s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8913;}s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8835;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8839;}}}}}}}}}}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8913;}}}}}}}s:1:"T";a:11:{s:1:"H";a:1:{s:1:"O";a:1:{s:1:"R";a:1:{s:1:"N";a:2:{s:1:";";a:1:{s:9:"codepoint";i:222;}s:9:"codepoint";i:222;}}}}s:1:"R";a:1:{s:1:"A";a:1:{s:1:"D";a:1:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8482;}}}}}s:1:"S";a:2:{s:1:"H";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1035;}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1062;}}}}s:1:"a";a:2:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:932;}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:356;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:354;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1058;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120087;}}}s:1:"h";a:2:{s:1:"e";a:2:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8756;}}}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:920;}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8201;}}}}}}}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8764;}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8771;}}}}}}s:1:"F";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8773;}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8776;}}}}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120139;}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8411;}}}}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119983;}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:358;}}}}}}}s:1:"U";a:14:{s:1:"a";a:2:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:218;}s:9:"codepoint";i:218;}}}}s:1:"r";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8607;}s:1:"o";a:1:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10569;}}}}}}}}s:1:"b";a:1:{s:1:"r";a:2:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1038;}}}s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:364;}}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:219;}s:9:"codepoint";i:219;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1059;}}}s:1:"d";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:368;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120088;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:217;}s:9:"codepoint";i:217;}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:362;}}}}}s:1:"n";a:2:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:"r";a:2:{s:1:"B";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:818;}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"c";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9183;}}s:1:"k";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9141;}}}}}}}}s:1:"P";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9181;}}}}}}}}}}}}}}}s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8899;}s:1:"P";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8846;}}}}}}}}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:370;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120140;}}}}s:1:"p";a:8:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8593;}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10514;}}}}s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8645;}}}}}}}}}}}}}}}s:1:"D";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8597;}}}}}}}}}}s:1:"E";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"b";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10606;}}}}}}}}}}}}s:1:"T";a:1:{s:1:"e";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8869;}s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8613;}}}}}}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8657;}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8661;}}}}}}}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"r";a:2:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8598;}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8599;}}}}}}}}}}}}}}s:1:"s";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:978;}s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:933;}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:366;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119984;}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:360;}}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:220;}s:9:"codepoint";i:220;}}}}s:1:"V";a:9:{s:1:"D";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8875;}}}}}s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10987;}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1042;}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8873;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10982;}}}}}}s:1:"e";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8897;}}s:1:"r";a:3:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8214;}}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8214;}s:1:"i";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:4:{s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8739;}}}}s:1:"L";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:124;}}}}}s:1:"S";a:1:{s:1:"e";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10072;}}}}}}}}}}s:1:"T";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8768;}}}}}}}}}}}s:1:"y";a:1:{s:1:"T";a:1:{s:1:"h";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8202;}}}}}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120089;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120141;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119985;}}}}s:1:"v";a:1:{s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8874;}}}}}}}s:1:"W";a:5:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:372;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8896;}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120090;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120142;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119986;}}}}}s:1:"X";a:4:{s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120091;}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:926;}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120143;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119987;}}}}}s:1:"Y";a:9:{s:1:"A";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1071;}}}}s:1:"I";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1031;}}}}s:1:"U";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1070;}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:221;}s:9:"codepoint";i:221;}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:374;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1067;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120092;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120144;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119988;}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:376;}}}}}s:1:"Z";a:8:{s:1:"H";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1046;}}}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:377;}}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:381;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1047;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:379;}}}}s:1:"e";a:2:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"W";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:"S";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8203;}}}}}}}}}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:918;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8488;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8484;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119989;}}}}}s:1:"a";a:16:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:225;}s:9:"codepoint";i:225;}}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:259;}}}}}}s:1:"c";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8766;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8767;}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:226;}s:9:"codepoint";i:226;}}}s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:180;}s:9:"codepoint";i:180;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1072;}}}s:1:"e";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:230;}s:9:"codepoint";i:230;}}}}s:1:"f";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8289;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120094;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:224;}s:9:"codepoint";i:224;}}}}}s:1:"l";a:2:{s:1:"e";a:2:{s:1:"f";a:1:{s:1:"s";a:1:{s:1:"y";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8501;}}}}}s:1:"p";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8501;}}}}s:1:"p";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:945;}}}}}s:1:"m";a:2:{s:1:"a";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:257;}}}s:1:"l";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10815;}}}}s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:38;}s:9:"codepoint";i:38;}}s:1:"n";a:2:{s:1:"d";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8743;}s:1:"a";a:1:{s:1:"n";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10837;}}}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10844;}}s:1:"s";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10840;}}}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10842;}}}s:1:"g";a:7:{s:1:";";a:1:{s:9:"codepoint";i:8736;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10660;}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8736;}}}s:1:"m";a:1:{s:1:"s";a:1:{s:1:"d";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8737;}s:1:"a";a:8:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10664;}}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10665;}}s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10666;}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10667;}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10668;}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10669;}}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10670;}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10671;}}}}}}s:1:"r";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8735;}s:1:"v";a:1:{s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8894;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10653;}}}}}}s:1:"s";a:2:{s:1:"p";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8738;}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8491;}}}s:1:"z";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9084;}}}}}}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:261;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120146;}}}}s:1:"p";a:7:{s:1:";";a:1:{s:9:"codepoint";i:8776;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10864;}}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10863;}}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8778;}}s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8779;}}}s:1:"o";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:39;}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8776;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8778;}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:229;}s:9:"codepoint";i:229;}}}}s:1:"s";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119990;}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:42;}}s:1:"y";a:1:{s:1:"m";a:1:{s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8776;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8781;}}}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:227;}s:9:"codepoint";i:227;}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:228;}s:9:"codepoint";i:228;}}}s:1:"w";a:2:{s:1:"c";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8755;}}}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10769;}}}}}}s:1:"b";a:16:{s:1:"N";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10989;}}}}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"k";a:4:{s:1:"c";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8780;}}}}}s:1:"e";a:1:{s:1:"p";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1014;}}}}}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8245;}}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8765;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8909;}}}}}}}}s:1:"r";a:2:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8893;}}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8965;}s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8965;}}}}}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9141;}s:1:"t";a:1:{s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9142;}}}}}}}}s:1:"c";a:2:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8780;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1073;}}}s:1:"d";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8222;}}}}}s:1:"e";a:5:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"u";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8757;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8757;}}}}}}s:1:"m";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10672;}}}}}}s:1:"p";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1014;}}}}s:1:"r";a:1:{s:1:"n";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8492;}}}}}s:1:"t";a:3:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:946;}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8502;}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8812;}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120095;}}}s:1:"i";a:1:{s:1:"g";a:7:{s:1:"c";a:3:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8898;}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9711;}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8899;}}}}s:1:"o";a:3:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10752;}}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10753;}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10754;}}}}}}}s:1:"s";a:2:{s:1:"q";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10758;}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9733;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9661;}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9651;}}}}}}}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10756;}}}}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8897;}}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8896;}}}}}}}}s:1:"k";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10509;}}}}}}s:1:"l";a:3:{s:1:"a";a:2:{s:1:"c";a:1:{s:1:"k";a:3:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"z";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10731;}}}}}}}}s:1:"s";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9642;}}}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:9652;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9662;}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9666;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9656;}}}}}}}}}}}}}}}}s:1:"n";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9251;}}}}s:1:"k";a:2:{i:1;a:2:{i:2;a:1:{s:1:";";a:1:{s:9:"codepoint";i:9618;}}i:4;a:1:{s:1:";";a:1:{s:9:"codepoint";i:9617;}}}i:3;a:1:{i:4;a:1:{s:1:";";a:1:{s:9:"codepoint";i:9619;}}}}s:1:"o";a:1:{s:1:"c";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9608;}}}}}s:1:"n";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8976;}}}}s:1:"o";a:4:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120147;}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8869;}s:1:"t";a:1:{s:1:"o";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8869;}}}}}s:1:"w";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8904;}}}}}s:1:"x";a:12:{s:1:"D";a:4:{s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9559;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9556;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9558;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9555;}}}s:1:"H";a:5:{s:1:";";a:1:{s:9:"codepoint";i:9552;}s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9574;}}s:1:"U";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9577;}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9572;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9575;}}}s:1:"U";a:4:{s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9565;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9562;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9564;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9561;}}}s:1:"V";a:7:{s:1:";";a:1:{s:9:"codepoint";i:9553;}s:1:"H";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9580;}}s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9571;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9568;}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9579;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9570;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9567;}}}s:1:"b";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10697;}}}}s:1:"d";a:4:{s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9557;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9554;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9488;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9484;}}}s:1:"h";a:5:{s:1:";";a:1:{s:9:"codepoint";i:9472;}s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9573;}}s:1:"U";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9576;}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9516;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9524;}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8863;}}}}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8862;}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8864;}}}}}}s:1:"u";a:4:{s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9563;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9560;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9496;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9492;}}}s:1:"v";a:7:{s:1:";";a:1:{s:9:"codepoint";i:9474;}s:1:"H";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9578;}}s:1:"L";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9569;}}s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9566;}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9532;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9508;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9500;}}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8245;}}}}}}s:1:"r";a:2:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:728;}}}}s:1:"v";a:1:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:166;}s:9:"codepoint";i:166;}}}}}s:1:"s";a:4:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119991;}}}s:1:"e";a:1:{s:1:"m";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8271;}}}}s:1:"i";a:1:{s:1:"m";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8765;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8909;}}}}s:1:"o";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:92;}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10693;}}}}}s:1:"u";a:2:{s:1:"l";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8226;}s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8226;}}}}}s:1:"m";a:1:{s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8782;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10926;}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8783;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8783;}}}}}}}s:1:"c";a:15:{s:1:"a";a:3:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:263;}}}}}s:1:"p";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8745;}s:1:"a";a:1:{s:1:"n";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10820;}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10825;}}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10827;}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10823;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10816;}}}}}s:1:"r";a:2:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8257;}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:711;}}}}}s:1:"c";a:4:{s:1:"a";a:2:{s:1:"p";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10829;}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:269;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:231;}s:9:"codepoint";i:231;}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:265;}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10828;}s:1:"s";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10832;}}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:267;}}}}s:1:"e";a:3:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:184;}s:9:"codepoint";i:184;}}}s:1:"m";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10674;}}}}}}s:1:"n";a:1:{s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:162;}s:9:"codepoint";i:162;s:1:"e";a:1:{s:1:"r";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:183;}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120096;}}}s:1:"h";a:3:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1095;}}}s:1:"e";a:1:{s:1:"c";a:1:{s:1:"k";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10003;}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10003;}}}}}}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:967;}}}s:1:"i";a:1:{s:1:"r";a:7:{s:1:";";a:1:{s:9:"codepoint";i:9675;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10691;}}s:1:"c";a:3:{s:1:";";a:1:{s:9:"codepoint";i:710;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8791;}}}s:1:"l";a:1:{s:1:"e";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8634;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8635;}}}}}}}}}}}s:1:"d";a:5:{s:1:"R";a:1:{s:1:";";a:1:{s:9:"codepoint";i:174;}}s:1:"S";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9416;}}s:1:"a";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8859;}}}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8858;}}}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8861;}}}}}}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8791;}}s:1:"f";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10768;}}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10991;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10690;}}}}}}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9827;}s:1:"u";a:1:{s:1:"i";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9827;}}}}}}}}s:1:"o";a:4:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:58;}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8788;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8788;}}}}}}s:1:"m";a:2:{s:1:"m";a:1:{s:1:"a";a:2:{s:1:";";a:1:{s:9:"codepoint";i:44;}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64;}}}}s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8705;}s:1:"f";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8728;}}}s:1:"l";a:1:{s:1:"e";a:2:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8705;}}}}}s:1:"x";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8450;}}}}}}}}s:1:"n";a:2:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8773;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10861;}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8750;}}}}}s:1:"p";a:3:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120148;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8720;}}}}s:1:"y";a:3:{s:1:";";a:1:{s:9:"codepoint";i:169;}s:9:"codepoint";i:169;s:1:"s";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8471;}}}}}}s:1:"r";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8629;}}}}s:1:"o";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10007;}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119992;}}}s:1:"u";a:2:{s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10959;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10961;}}}s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10960;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10962;}}}}}s:1:"t";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8943;}}}}}s:1:"u";a:7:{s:1:"d";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:2:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10552;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10549;}}}}}}s:1:"e";a:2:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8926;}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8927;}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8630;}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10557;}}}}}}s:1:"p";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8746;}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10824;}}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10822;}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10826;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8845;}}}}s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10821;}}}}s:1:"r";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8631;}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10556;}}}}}s:1:"l";a:1:{s:1:"y";a:3:{s:1:"e";a:1:{s:1:"q";a:2:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8926;}}}}}s:1:"s";a:1:{s:1:"u";a:1:{s:1:"c";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8927;}}}}}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8910;}}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8911;}}}}}}}}s:1:"r";a:1:{s:1:"e";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:164;}s:9:"codepoint";i:164;}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8630;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8631;}}}}}}}}}}}}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8910;}}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8911;}}}}}s:1:"w";a:2:{s:1:"c";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8754;}}}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8753;}}}}}s:1:"y";a:1:{s:1:"l";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9005;}}}}}}}s:1:"d";a:19:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8659;}}}}s:1:"H";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10597;}}}}s:1:"a";a:4:{s:1:"g";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8224;}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8504;}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8595;}}}s:1:"s";a:1:{s:1:"h";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8208;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8867;}}}}}s:1:"b";a:2:{s:1:"k";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10511;}}}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:733;}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:271;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1076;}}}s:1:"d";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8518;}s:1:"a";a:2:{s:1:"g";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8225;}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8650;}}}}s:1:"o";a:1:{s:1:"t";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10871;}}}}}}}s:1:"e";a:3:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:176;}s:9:"codepoint";i:176;}s:1:"l";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:948;}}}}s:1:"m";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10673;}}}}}}}s:1:"f";a:2:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10623;}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120097;}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8643;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8642;}}}}}s:1:"i";a:5:{s:1:"a";a:1:{s:1:"m";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8900;}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"d";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8900;}s:1:"s";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9830;}}}}}}}}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9830;}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:168;}}s:1:"g";a:1:{s:1:"a";a:1:{s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:989;}}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8946;}}}}s:1:"v";a:3:{s:1:";";a:1:{s:9:"codepoint";i:247;}s:1:"i";a:1:{s:1:"d";a:1:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:247;}s:9:"codepoint";i:247;s:1:"o";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8903;}}}}}}}}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8903;}}}}}}s:1:"j";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1106;}}}}s:1:"l";a:1:{s:1:"c";a:2:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8990;}}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8973;}}}}}}s:1:"o";a:5:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:36;}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120149;}}}s:1:"t";a:5:{s:1:";";a:1:{s:9:"codepoint";i:729;}s:1:"e";a:1:{s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8784;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8785;}}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8760;}}}}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8724;}}}}}s:1:"s";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8865;}}}}}}}}s:1:"u";a:1:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8966;}}}}}}}}}}}}}s:1:"w";a:1:{s:1:"n";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8595;}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8650;}}}}}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8643;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8642;}}}}}}}}}}}}}}}}s:1:"r";a:2:{s:1:"b";a:1:{s:1:"k";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10512;}}}}}}}s:1:"c";a:2:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8991;}}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8972;}}}}}}s:1:"s";a:3:{s:1:"c";a:2:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119993;}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1109;}}}s:1:"o";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10742;}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:273;}}}}}}s:1:"t";a:2:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8945;}}}}s:1:"r";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9663;}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9662;}}}}}s:1:"u";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8693;}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10607;}}}}}s:1:"w";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10662;}}}}}}}s:1:"z";a:2:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1119;}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10239;}}}}}}}}}s:1:"e";a:18:{s:1:"D";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10871;}}}}s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8785;}}}}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:233;}s:9:"codepoint";i:233;}}}}s:1:"s";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10862;}}}}}}s:1:"c";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:283;}}}}}s:1:"i";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8790;}s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:234;}s:9:"codepoint";i:234;}}}s:1:"o";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8789;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1101;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:279;}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8519;}}s:1:"f";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8786;}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120098;}}}s:1:"g";a:3:{s:1:";";a:1:{s:9:"codepoint";i:10906;}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:232;}s:9:"codepoint";i:232;}}}}s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10902;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10904;}}}}}}s:1:"l";a:4:{s:1:";";a:1:{s:9:"codepoint";i:10905;}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9191;}}}}}}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8467;}}s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10901;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10903;}}}}}}s:1:"m";a:3:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:275;}}}}s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8709;}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8709;}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8709;}}}}}s:1:"s";a:1:{s:1:"p";a:2:{i:1;a:2:{i:3;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8196;}}i:4;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8197;}}}s:1:";";a:1:{s:9:"codepoint";i:8195;}}}}s:1:"n";a:2:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:331;}}s:1:"s";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8194;}}}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:281;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120150;}}}}s:1:"p";a:3:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8917;}s:1:"s";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10723;}}}}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10865;}}}}s:1:"s";a:1:{s:1:"i";a:3:{s:1:";";a:1:{s:9:"codepoint";i:1013;}s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:949;}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:949;}}}}}s:1:"q";a:4:{s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8790;}}}}s:1:"o";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8789;}}}}}}s:1:"s";a:2:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8770;}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:2:{s:1:"g";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10902;}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10901;}}}}}}}}}}s:1:"u";a:3:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:61;}}}}s:1:"e";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8799;}}}}s:1:"i";a:1:{s:1:"v";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8801;}s:1:"D";a:1:{s:1:"D";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10872;}}}}}}s:1:"v";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10725;}}}}}}}}s:1:"r";a:2:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8787;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10609;}}}}}s:1:"s";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8495;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8784;}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8770;}}}}s:1:"t";a:2:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:951;}}s:1:"h";a:2:{s:1:";";a:1:{s:9:"codepoint";i:240;}s:9:"codepoint";i:240;}}s:1:"u";a:2:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:235;}s:9:"codepoint";i:235;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8364;}}}}s:1:"x";a:3:{s:1:"c";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:33;}}}s:1:"i";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8707;}}}}s:1:"p";a:2:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8496;}}}}}}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8519;}}}}}}}}}}}}}s:1:"f";a:11:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8786;}}}}}}}}}}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1092;}}}s:1:"e";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9792;}}}}}}s:1:"f";a:3:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64259;}}}}}s:1:"l";a:2:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64256;}}}s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64260;}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120099;}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64257;}}}}}s:1:"l";a:3:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9837;}}}s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:64258;}}}}s:1:"t";a:1:{s:1:"n";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9649;}}}}}s:1:"n";a:1:{s:1:"o";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:402;}}}}s:1:"o";a:2:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120151;}}}s:1:"r";a:2:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8704;}}}}s:1:"k";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8916;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10969;}}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10765;}}}}}}}}s:1:"r";a:2:{s:1:"a";a:2:{s:1:"c";a:6:{i:1;a:6:{i:2;a:2:{s:1:";";a:1:{s:9:"codepoint";i:189;}s:9:"codepoint";i:189;}i:3;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8531;}}i:4;a:2:{s:1:";";a:1:{s:9:"codepoint";i:188;}s:9:"codepoint";i:188;}i:5;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8533;}}i:6;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8537;}}i:8;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8539;}}}i:2;a:2:{i:3;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8532;}}i:5;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8534;}}}i:3;a:3:{i:4;a:2:{s:1:";";a:1:{s:9:"codepoint";i:190;}s:9:"codepoint";i:190;}i:5;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8535;}}i:8;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8540;}}}i:4;a:1:{i:5;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8536;}}}i:5;a:2:{i:6;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8538;}}i:8;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8541;}}}i:7;a:1:{i:8;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8542;}}}}s:1:"s";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8260;}}}}s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8994;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119995;}}}}}s:1:"g";a:16:{s:1:"E";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8807;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10892;}}}s:1:"a";a:3:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:501;}}}}}s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:2:{s:1:";";a:1:{s:9:"codepoint";i:947;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:989;}}}}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10886;}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:287;}}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:285;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1075;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:289;}}}}s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8805;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8923;}}s:1:"q";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8805;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8807;}}s:1:"s";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10878;}}}}}}}s:1:"s";a:4:{s:1:";";a:1:{s:9:"codepoint";i:10878;}s:1:"c";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10921;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10880;}s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10882;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10884;}}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10900;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120100;}}}s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8811;}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8921;}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8503;}}}}}s:1:"j";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1107;}}}}s:1:"l";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8823;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10898;}}s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10917;}}s:1:"j";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10916;}}}s:1:"n";a:4:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8809;}}s:1:"a";a:1:{s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10890;}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10890;}}}}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10888;}s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10888;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8809;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8935;}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120152;}}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:96;}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8458;}}}s:1:"i";a:1:{s:1:"m";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8819;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10894;}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10896;}}}}}s:1:"t";a:7:{s:1:";";a:1:{s:9:"codepoint";i:62;}s:9:"codepoint";i:62;s:1:"c";a:2:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10919;}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10874;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8919;}}}}s:1:"l";a:1:{s:1:"P";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10645;}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10876;}}}}}}s:1:"r";a:5:{s:1:"a";a:2:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10886;}}}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10616;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8919;}}}}s:1:"e";a:1:{s:1:"q";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8923;}}}}}s:1:"q";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10892;}}}}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8823;}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8819;}}}}}}}s:1:"h";a:10:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8660;}}}}s:1:"a";a:4:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8202;}}}}}s:1:"l";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:189;}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8459;}}}}}s:1:"r";a:2:{s:1:"d";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1098;}}}}s:1:"r";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8596;}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10568;}}}}s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8621;}}}}}s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8463;}}}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:293;}}}}}s:1:"e";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9829;}s:1:"u";a:1:{s:1:"i";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9829;}}}}}}}}s:1:"l";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8230;}}}}}s:1:"r";a:1:{s:1:"c";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8889;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120101;}}}s:1:"k";a:1:{s:1:"s";a:2:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10533;}}}}}}s:1:"w";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10534;}}}}}}}}s:1:"o";a:5:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8703;}}}}s:1:"m";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8763;}}}}}s:1:"o";a:1:{s:1:"k";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8617;}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8618;}}}}}}}}}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120153;}}}s:1:"r";a:1:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8213;}}}}}}s:1:"s";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119997;}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8463;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:295;}}}}}}s:1:"y";a:2:{s:1:"b";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8259;}}}}}s:1:"p";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8208;}}}}}}}s:1:"i";a:15:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:237;}s:9:"codepoint";i:237;}}}}}s:1:"c";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8291;}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:238;}s:9:"codepoint";i:238;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1080;}}}s:1:"e";a:2:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1077;}}}s:1:"x";a:1:{s:1:"c";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:161;}s:9:"codepoint";i:161;}}}}s:1:"f";a:2:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8660;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120102;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:236;}s:9:"codepoint";i:236;}}}}}s:1:"i";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8520;}s:1:"i";a:2:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10764;}}}}s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8749;}}}}s:1:"n";a:1:{s:1:"f";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10716;}}}}}s:1:"o";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8489;}}}}}s:1:"j";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:307;}}}}}s:1:"m";a:3:{s:1:"a";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:299;}}}s:1:"g";a:3:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8465;}}s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8464;}}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8465;}}}}}}s:1:"t";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:305;}}}}s:1:"o";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8887;}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:437;}}}}}s:1:"n";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8712;}s:1:"c";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8453;}}}}}s:1:"f";a:1:{s:1:"i";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8734;}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10717;}}}}}}}s:1:"o";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:305;}}}}}s:1:"t";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8747;}s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8890;}}}}s:1:"e";a:2:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8484;}}}}}s:1:"r";a:1:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8890;}}}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10775;}}}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10812;}}}}}}}s:1:"o";a:4:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1105;}}}s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:303;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120154;}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:953;}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10812;}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:191;}s:9:"codepoint";i:191;}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119998;}}}s:1:"i";a:1:{s:1:"n";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8712;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8953;}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8949;}}}}s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8948;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8947;}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8712;}}}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8290;}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:297;}}}}}}s:1:"u";a:2:{s:1:"k";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1110;}}}}s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:239;}s:9:"codepoint";i:239;}}}}s:1:"j";a:6:{s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:309;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1081;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120103;}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:567;}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120155;}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:119999;}}}s:1:"e";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1112;}}}}}}s:1:"u";a:1:{s:1:"k";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1108;}}}}}}s:1:"k";a:8:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"a";a:2:{s:1:";";a:1:{s:9:"codepoint";i:954;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1008;}}}}}}s:1:"c";a:2:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:311;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1082;}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120104;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:312;}}}}}}s:1:"h";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1093;}}}}s:1:"j";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1116;}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120156;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120000;}}}}}s:1:"l";a:22:{s:1:"A";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8666;}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8656;}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10523;}}}}}}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10510;}}}}}s:1:"E";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8806;}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10891;}}}s:1:"H";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10594;}}}}s:1:"a";a:9:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:314;}}}}}s:1:"e";a:1:{s:1:"m";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10676;}}}}}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8466;}}}}}s:1:"m";a:1:{s:1:"b";a:1:{s:1:"d";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:955;}}}}}s:1:"n";a:1:{s:1:"g";a:3:{s:1:";";a:1:{s:9:"codepoint";i:10216;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10641;}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10216;}}}}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10885;}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:171;}s:9:"codepoint";i:171;}}}s:1:"r";a:1:{s:1:"r";a:8:{s:1:";";a:1:{s:9:"codepoint";i:8592;}s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8676;}s:1:"f";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10527;}}}}s:1:"f";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10525;}}}s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8617;}}}s:1:"l";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8619;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10553;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10611;}}}}s:1:"t";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8610;}}}}}s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:10923;}s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10521;}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10925;}}}}s:1:"b";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10508;}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10098;}}}}s:1:"r";a:2:{s:1:"a";a:1:{s:1:"c";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:123;}}s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:91;}}}}s:1:"k";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10635;}}s:1:"s";a:1:{s:1:"l";a:2:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10639;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10637;}}}}}}}s:1:"c";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:318;}}}}}s:1:"e";a:2:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:316;}}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8968;}}}}s:1:"u";a:1:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:123;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1083;}}}s:1:"d";a:4:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10550;}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8220;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8222;}}}}}s:1:"r";a:2:{s:1:"d";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10599;}}}}}s:1:"u";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10571;}}}}}}}s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8626;}}}}s:1:"e";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8804;}s:1:"f";a:1:{s:1:"t";a:5:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8592;}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8610;}}}}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8637;}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8636;}}}}}}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8647;}}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8596;}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8646;}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8651;}}}}}}}}}s:1:"s";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8621;}}}}}}}}}}}}}}}}s:1:"t";a:1:{s:1:"h";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8907;}}}}}}}}}}}}}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8922;}}s:1:"q";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8804;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8806;}}s:1:"s";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10877;}}}}}}}s:1:"s";a:5:{s:1:";";a:1:{s:9:"codepoint";i:10877;}s:1:"c";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10920;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10879;}s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10881;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10883;}}}}}}s:1:"g";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10899;}}}}s:1:"s";a:5:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10885;}}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8918;}}}}s:1:"e";a:1:{s:1:"q";a:2:{s:1:"g";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8922;}}}}s:1:"q";a:1:{s:1:"g";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10891;}}}}}}}s:1:"g";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8822;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8818;}}}}}}}s:1:"f";a:3:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10620;}}}}}s:1:"l";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8970;}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120105;}}}s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8822;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10897;}}}s:1:"h";a:2:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8637;}}s:1:"u";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8636;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10602;}}}}}s:1:"b";a:1:{s:1:"l";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9604;}}}}}s:1:"j";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1113;}}}}s:1:"l";a:5:{s:1:";";a:1:{s:9:"codepoint";i:8810;}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8647;}}}}s:1:"c";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8990;}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10603;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9722;}}}}}s:1:"m";a:2:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:320;}}}}}s:1:"o";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9136;}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9136;}}}}}}}}}}s:1:"n";a:4:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8808;}}s:1:"a";a:1:{s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10889;}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10889;}}}}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10887;}s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10887;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8808;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8934;}}}}}s:1:"o";a:8:{s:1:"a";a:2:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10220;}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8701;}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10214;}}}}s:1:"n";a:1:{s:1:"g";a:3:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10229;}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10231;}}}}}}}}}}}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10236;}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10230;}}}}}}}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8619;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8620;}}}}}}}}}}}}}s:1:"p";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10629;}}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120157;}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10797;}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10804;}}}}}}s:1:"w";a:2:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8727;}}}}s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:95;}}}}}s:1:"z";a:3:{s:1:";";a:1:{s:9:"codepoint";i:9674;}s:1:"e";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9674;}}}}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10731;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:40;}s:1:"l";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10643;}}}}}}s:1:"r";a:5:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8646;}}}}s:1:"c";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8991;}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8651;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10605;}}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8206;}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8895;}}}}}s:1:"s";a:6:{s:1:"a";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8249;}}}}}s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120001;}}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8624;}}s:1:"i";a:1:{s:1:"m";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8818;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10893;}}s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10895;}}}}s:1:"q";a:2:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:91;}}s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8216;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8218;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:322;}}}}}}s:1:"t";a:9:{s:1:";";a:1:{s:9:"codepoint";i:60;}s:9:"codepoint";i:60;s:1:"c";a:2:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10918;}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10873;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8918;}}}}s:1:"h";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8907;}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8905;}}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10614;}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10875;}}}}}}s:1:"r";a:2:{s:1:"P";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10646;}}}}s:1:"i";a:3:{s:1:";";a:1:{s:9:"codepoint";i:9667;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8884;}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9666;}}}}}s:1:"u";a:1:{s:1:"r";a:2:{s:1:"d";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10570;}}}}}}s:1:"u";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10598;}}}}}}}}s:1:"m";a:14:{s:1:"D";a:1:{s:1:"D";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8762;}}}}}s:1:"a";a:4:{s:1:"c";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:175;}s:9:"codepoint";i:175;}}s:1:"l";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9794;}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10016;}s:1:"e";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10016;}}}}}}s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8614;}s:1:"s";a:1:{s:1:"t";a:1:{s:1:"o";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8614;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8615;}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8612;}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8613;}}}}}}}s:1:"r";a:1:{s:1:"k";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9646;}}}}}}s:1:"c";a:2:{s:1:"o";a:1:{s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10793;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1084;}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8212;}}}}}s:1:"e";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8737;}}}}}}}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120106;}}}s:1:"h";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8487;}}}s:1:"i";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:181;}s:9:"codepoint";i:181;}}}s:1:"d";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8739;}s:1:"a";a:1:{s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:42;}}}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10992;}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:183;}s:9:"codepoint";i:183;}}}}s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8722;}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8863;}}s:1:"d";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8760;}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10794;}}}}}}}s:1:"l";a:2:{s:1:"c";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10971;}}}s:1:"d";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8230;}}}}s:1:"n";a:1:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8723;}}}}}}s:1:"o";a:2:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8871;}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120158;}}}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8723;}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120002;}}}s:1:"t";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8766;}}}}}}s:1:"u";a:3:{s:1:";";a:1:{s:9:"codepoint";i:956;}s:1:"l";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8888;}}}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8888;}}}}}}s:1:"n";a:23:{s:1:"L";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8653;}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8654;}}}}}}}}}}}}}}}s:1:"R";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8655;}}}}}}}}}}}s:1:"V";a:2:{s:1:"D";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8879;}}}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8878;}}}}}}s:1:"a";a:4:{s:1:"b";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8711;}}}}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:324;}}}}}s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8777;}s:1:"o";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:329;}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8777;}}}}}}s:1:"t";a:1:{s:1:"u";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9838;}s:1:"a";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9838;}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8469;}}}}}}}}s:1:"b";a:1:{s:1:"s";a:1:{s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:160;}s:9:"codepoint";i:160;}}}s:1:"c";a:5:{s:1:"a";a:2:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10819;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:328;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:326;}}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8775;}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10818;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1085;}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8211;}}}}}s:1:"e";a:6:{s:1:";";a:1:{s:9:"codepoint";i:8800;}s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8663;}}}}s:1:"a";a:1:{s:1:"r";a:2:{s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10532;}}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8599;}s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8599;}}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8802;}}}}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10536;}}}}}s:1:"x";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8708;}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8708;}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120107;}}}s:1:"g";a:3:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8817;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8817;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8821;}}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8815;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8815;}}}}s:1:"h";a:3:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8654;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8622;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10994;}}}}}s:1:"i";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8715;}s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8956;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8954;}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8715;}}}s:1:"j";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1114;}}}}s:1:"l";a:6:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8653;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8602;}}}}s:1:"d";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8229;}}}s:1:"e";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8816;}s:1:"f";a:1:{s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8602;}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8622;}}}}}}}}}}}}}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8816;}}s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8814;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8820;}}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8814;}s:1:"r";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8938;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8940;}}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8740;}}}}s:1:"o";a:2:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120159;}}}s:1:"t";a:4:{s:1:";";a:1:{s:9:"codepoint";i:172;}s:9:"codepoint";i:172;s:1:"i";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8713;}s:1:"v";a:3:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8713;}}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8951;}}s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8950;}}}}}s:1:"n";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8716;}s:1:"v";a:3:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8716;}}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8958;}}s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8957;}}}}}}}s:1:"p";a:3:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8742;}s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8742;}}}}}}}}s:1:"o";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10772;}}}}}}s:1:"r";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8832;}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8928;}}}}s:1:"e";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8832;}}}}}s:1:"r";a:4:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8655;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8603;}}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8603;}}}}}}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8939;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8941;}}}}}}s:1:"s";a:7:{s:1:"c";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8833;}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8929;}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120003;}}}s:1:"h";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"t";a:2:{s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8740;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8742;}}}}}}}}}}}}}s:1:"i";a:1:{s:1:"m";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8769;}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8772;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8772;}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8740;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8742;}}}}s:1:"q";a:1:{s:1:"s";a:1:{s:1:"u";a:2:{s:1:"b";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8930;}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8931;}}}}}}s:1:"u";a:3:{s:1:"b";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8836;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8840;}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8840;}}}}}}}s:1:"c";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8833;}}}s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8837;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8841;}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8841;}}}}}}}}}s:1:"t";a:4:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8825;}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:241;}s:9:"codepoint";i:241;}}}}s:1:"l";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8824;}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8938;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8940;}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8939;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8941;}}}}}}}}}}}}}}}}s:1:"u";a:2:{s:1:";";a:1:{s:9:"codepoint";i:957;}s:1:"m";a:3:{s:1:";";a:1:{s:9:"codepoint";i:35;}s:1:"e";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8470;}}}}s:1:"s";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8199;}}}}}s:1:"v";a:6:{s:1:"D";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8877;}}}}}s:1:"H";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10500;}}}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8876;}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"f";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10718;}}}}}}s:1:"l";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10498;}}}}}s:1:"r";a:1:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10499;}}}}}}s:1:"w";a:3:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8662;}}}}s:1:"a";a:1:{s:1:"r";a:2:{s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10531;}}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8598;}s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8598;}}}}}}s:1:"n";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10535;}}}}}}}s:1:"o";a:18:{s:1:"S";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9416;}}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:243;}s:9:"codepoint";i:243;}}}}s:1:"s";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8859;}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8858;}s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:244;}s:9:"codepoint";i:244;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1086;}}}s:1:"d";a:5:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8861;}}}}s:1:"b";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:337;}}}}}s:1:"i";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10808;}}}s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8857;}}}s:1:"s";a:1:{s:1:"o";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10684;}}}}}}s:1:"e";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:339;}}}}}s:1:"f";a:2:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10687;}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120108;}}}s:1:"g";a:3:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:731;}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:242;}s:9:"codepoint";i:242;}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10689;}}}s:1:"h";a:2:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10677;}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8486;}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8750;}}}}s:1:"l";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8634;}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10686;}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"s";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10683;}}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8254;}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10688;}}}s:1:"m";a:3:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:333;}}}}s:1:"e";a:1:{s:1:"g";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:969;}}}}s:1:"i";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:959;}}}}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10678;}}s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8854;}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120160;}}}}s:1:"p";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10679;}}}s:1:"e";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10681;}}}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8853;}}}}}s:1:"r";a:7:{s:1:";";a:1:{s:9:"codepoint";i:8744;}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8635;}}}}s:1:"d";a:4:{s:1:";";a:1:{s:9:"codepoint";i:10845;}s:1:"e";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8500;}s:1:"o";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8500;}}}}}s:1:"f";a:2:{s:1:";";a:1:{s:9:"codepoint";i:170;}s:9:"codepoint";i:170;}s:1:"m";a:2:{s:1:";";a:1:{s:9:"codepoint";i:186;}s:9:"codepoint";i:186;}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8886;}}}}}s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10838;}}}s:1:"s";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10839;}}}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10843;}}}s:1:"s";a:3:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8500;}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:2:{s:1:";";a:1:{s:9:"codepoint";i:248;}s:9:"codepoint";i:248;}}}}s:1:"o";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8856;}}}}s:1:"t";a:1:{s:1:"i";a:2:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:245;}s:9:"codepoint";i:245;}}}s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8855;}s:1:"a";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10806;}}}}}}}}s:1:"u";a:1:{s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:246;}s:9:"codepoint";i:246;}}}s:1:"v";a:1:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9021;}}}}}}s:1:"p";a:12:{s:1:"a";a:1:{s:1:"r";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8741;}s:1:"a";a:3:{s:1:";";a:1:{s:9:"codepoint";i:182;}s:9:"codepoint";i:182;s:1:"l";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8741;}}}}}}s:1:"s";a:2:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10995;}}}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:11005;}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8706;}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1087;}}}s:1:"e";a:1:{s:1:"r";a:5:{s:1:"c";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:37;}}}}s:1:"i";a:1:{s:1:"o";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:46;}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8240;}}}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8869;}}s:1:"t";a:1:{s:1:"e";a:1:{s:1:"n";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8241;}}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120109;}}}s:1:"h";a:3:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:966;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:966;}}}s:1:"m";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8499;}}}}}s:1:"o";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9742;}}}}}s:1:"i";a:3:{s:1:";";a:1:{s:9:"codepoint";i:960;}s:1:"t";a:1:{s:1:"c";a:1:{s:1:"h";a:1:{s:1:"f";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8916;}}}}}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:982;}}}s:1:"l";a:2:{s:1:"a";a:1:{s:1:"n";a:2:{s:1:"c";a:1:{s:1:"k";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8463;}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8462;}}}}s:1:"k";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8463;}}}}}s:1:"u";a:1:{s:1:"s";a:9:{s:1:";";a:1:{s:9:"codepoint";i:43;}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10787;}}}}}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8862;}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10786;}}}}s:1:"d";a:2:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8724;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10789;}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10866;}}s:1:"m";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:177;}s:9:"codepoint";i:177;}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10790;}}}}s:1:"t";a:1:{s:1:"w";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10791;}}}}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:177;}}s:1:"o";a:3:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10773;}}}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120161;}}}s:1:"u";a:1:{s:1:"n";a:1:{s:1:"d";a:2:{s:1:";";a:1:{s:9:"codepoint";i:163;}s:9:"codepoint";i:163;}}}}s:1:"r";a:10:{s:1:";";a:1:{s:9:"codepoint";i:8826;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10931;}}s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10935;}}}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8828;}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10927;}s:1:"c";a:6:{s:1:";";a:1:{s:9:"codepoint";i:8826;}s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10935;}}}}}}}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"l";a:1:{s:1:"y";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8828;}}}}}}}}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10927;}}}s:1:"n";a:3:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10937;}}}}}}}s:1:"e";a:1:{s:1:"q";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10933;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8936;}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8830;}}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8242;}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8473;}}}}}s:1:"n";a:3:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10933;}}s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10937;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8936;}}}}}s:1:"o";a:3:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8719;}}s:1:"f";a:3:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9006;}}}}}s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8978;}}}}}s:1:"s";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8979;}}}}}}s:1:"p";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8733;}s:1:"t";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8733;}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8830;}}}}s:1:"u";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8880;}}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120005;}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:968;}}}s:1:"u";a:1:{s:1:"n";a:1:{s:1:"c";a:1:{s:1:"s";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8200;}}}}}}}s:1:"q";a:6:{s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120110;}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10764;}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120162;}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8279;}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120006;}}}}s:1:"u";a:3:{s:1:"a";a:1:{s:1:"t";a:2:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"n";a:1:{s:1:"i";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8461;}}}}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10774;}}}}}}s:1:"e";a:1:{s:1:"s";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:63;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8799;}}}}}}s:1:"o";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:34;}s:9:"codepoint";i:34;}}}}s:1:"r";a:21:{s:1:"A";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8667;}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8658;}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10524;}}}}}}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10511;}}}}}s:1:"H";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10596;}}}}s:1:"a";a:7:{s:1:"c";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10714;}}s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:341;}}}}}s:1:"d";a:1:{s:1:"i";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8730;}}}}s:1:"e";a:1:{s:1:"m";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"y";a:1:{s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10675;}}}}}}}s:1:"n";a:1:{s:1:"g";a:4:{s:1:";";a:1:{s:9:"codepoint";i:10217;}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10642;}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10661;}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10217;}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:187;}s:9:"codepoint";i:187;}}}s:1:"r";a:1:{s:1:"r";a:11:{s:1:";";a:1:{s:9:"codepoint";i:8594;}s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10613;}}}s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8677;}s:1:"f";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10528;}}}}s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10547;}}s:1:"f";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10526;}}}s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8618;}}}s:1:"l";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8620;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10565;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10612;}}}}s:1:"t";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8611;}}}s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8605;}}}}s:1:"t";a:2:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10522;}}}}s:1:"i";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8758;}s:1:"n";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8474;}}}}}}}}}s:1:"b";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10509;}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10099;}}}}s:1:"r";a:2:{s:1:"a";a:1:{s:1:"c";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:125;}}s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:93;}}}}s:1:"k";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10636;}}s:1:"s";a:1:{s:1:"l";a:2:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10638;}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10640;}}}}}}}s:1:"c";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:345;}}}}}s:1:"e";a:2:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:343;}}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8969;}}}}s:1:"u";a:1:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:125;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1088;}}}s:1:"d";a:4:{s:1:"c";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10551;}}}s:1:"l";a:1:{s:1:"d";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10601;}}}}}}s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8221;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8221;}}}}}s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8627;}}}}s:1:"e";a:3:{s:1:"a";a:1:{s:1:"l";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8476;}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8475;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8476;}}}}}s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8477;}}}}s:1:"c";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9645;}}}s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:174;}s:9:"codepoint";i:174;}}s:1:"f";a:3:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10621;}}}}}s:1:"l";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8971;}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120111;}}}s:1:"h";a:2:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8641;}}s:1:"u";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8640;}s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10604;}}}}}s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:961;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1009;}}}}s:1:"i";a:3:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:6:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8594;}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8611;}}}}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8641;}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8640;}}}}}}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8644;}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8652;}}}}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8649;}}}}}}}}}}}}s:1:"s";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8605;}}}}}}}}}}}s:1:"t";a:1:{s:1:"h";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8908;}}}}}}}}}}}}}}s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:730;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8787;}}}}}}}}}}}}s:1:"l";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8644;}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8652;}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8207;}}}s:1:"m";a:1:{s:1:"o";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9137;}s:1:"a";a:1:{s:1:"c";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9137;}}}}}}}}}}s:1:"n";a:1:{s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10990;}}}}}s:1:"o";a:4:{s:1:"a";a:2:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10221;}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8702;}}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10215;}}}}s:1:"p";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10630;}}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120163;}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10798;}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10805;}}}}}}}s:1:"p";a:2:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:41;}s:1:"g";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10644;}}}}}s:1:"p";a:1:{s:1:"o";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10770;}}}}}}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8649;}}}}}s:1:"s";a:4:{s:1:"a";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8250;}}}}}s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120007;}}}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8625;}}s:1:"q";a:2:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:93;}}s:1:"u";a:1:{s:1:"o";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8217;}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8217;}}}}}}s:1:"t";a:3:{s:1:"h";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8908;}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8906;}}}}}s:1:"r";a:1:{s:1:"i";a:4:{s:1:";";a:1:{s:9:"codepoint";i:9657;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8885;}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9656;}}s:1:"l";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10702;}}}}}}}}s:1:"u";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10600;}}}}}}}s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8478;}}}s:1:"s";a:19:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:347;}}}}}}s:1:"b";a:1:{s:1:"q";a:1:{s:1:"u";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8218;}}}}}s:1:"c";a:10:{s:1:";";a:1:{s:9:"codepoint";i:8827;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10932;}}s:1:"a";a:2:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10936;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:353;}}}}}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8829;}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10928;}s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:351;}}}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:349;}}}}s:1:"n";a:3:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10934;}}s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10938;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8937;}}}}}s:1:"p";a:1:{s:1:"o";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10771;}}}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8831;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1089;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8901;}s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8865;}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10854;}}}}}s:1:"e";a:7:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8664;}}}}s:1:"a";a:1:{s:1:"r";a:2:{s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10533;}}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8600;}s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8600;}}}}}}s:1:"c";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:167;}s:9:"codepoint";i:167;}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:59;}}}s:1:"s";a:1:{s:1:"w";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10537;}}}}}s:1:"t";a:1:{s:1:"m";a:2:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8726;}}}}}s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8726;}}}}s:1:"x";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10038;}}}}s:1:"f";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:120112;}s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8994;}}}}}}s:1:"h";a:4:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9839;}}}}s:1:"c";a:2:{s:1:"h";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1097;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1096;}}}s:1:"o";a:1:{s:1:"r";a:1:{s:1:"t";a:2:{s:1:"m";a:1:{s:1:"i";a:1:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8739;}}}}s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8741;}}}}}}}}}}}}s:1:"y";a:2:{s:1:";";a:1:{s:9:"codepoint";i:173;}s:9:"codepoint";i:173;}}s:1:"i";a:2:{s:1:"g";a:1:{s:1:"m";a:1:{s:1:"a";a:3:{s:1:";";a:1:{s:9:"codepoint";i:963;}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:962;}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:962;}}}}}s:1:"m";a:8:{s:1:";";a:1:{s:9:"codepoint";i:8764;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10858;}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8771;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8771;}}}s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10910;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10912;}}}s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10909;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10911;}}}s:1:"n";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8774;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10788;}}}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10610;}}}}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8592;}}}}}s:1:"m";a:4:{s:1:"a";a:2:{s:1:"l";a:1:{s:1:"l";a:1:{s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"m";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8726;}}}}}}}}}}}s:1:"s";a:1:{s:1:"h";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10803;}}}}}s:1:"e";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"s";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10724;}}}}}}}s:1:"i";a:2:{s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8739;}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8995;}}}}s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10922;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10924;}}}}s:1:"o";a:3:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1100;}}}}}s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:47;}s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10692;}s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9023;}}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120164;}}}}s:1:"p";a:1:{s:1:"a";a:2:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:"s";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9824;}s:1:"u";a:1:{s:1:"i";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9824;}}}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8741;}}}}s:1:"q";a:3:{s:1:"c";a:2:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8851;}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8852;}}}}s:1:"s";a:1:{s:1:"u";a:2:{s:1:"b";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8847;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8849;}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8847;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8849;}}}}}}}s:1:"p";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8848;}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8850;}}s:1:"s";a:1:{s:1:"e";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8848;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8850;}}}}}}}}}s:1:"u";a:3:{s:1:";";a:1:{s:9:"codepoint";i:9633;}s:1:"a";a:1:{s:1:"r";a:2:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9633;}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9642;}}}}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9642;}}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8594;}}}}}s:1:"s";a:4:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120008;}}}s:1:"e";a:1:{s:1:"t";a:1:{s:1:"m";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8726;}}}}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8995;}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8902;}}}}}}s:1:"t";a:2:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9734;}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9733;}}}}s:1:"r";a:2:{s:1:"a";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:"e";a:1:{s:1:"p";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1013;}}}}}}}}s:1:"p";a:1:{s:1:"h";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:981;}}}}}}}}}s:1:"n";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:175;}}}}}s:1:"u";a:5:{s:1:"b";a:9:{s:1:";";a:1:{s:9:"codepoint";i:8834;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10949;}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10941;}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8838;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10947;}}}}}s:1:"m";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10945;}}}}}s:1:"n";a:2:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10955;}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8842;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10943;}}}}}s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10617;}}}}}s:1:"s";a:3:{s:1:"e";a:1:{s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8834;}s:1:"e";a:1:{s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8838;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10949;}}}}s:1:"n";a:1:{s:1:"e";a:1:{s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8842;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10955;}}}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10951;}}}s:1:"u";a:2:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10965;}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10963;}}}}}s:1:"c";a:1:{s:1:"c";a:6:{s:1:";";a:1:{s:9:"codepoint";i:8827;}s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10936;}}}}}}}s:1:"c";a:1:{s:1:"u";a:1:{s:1:"r";a:1:{s:1:"l";a:1:{s:1:"y";a:1:{s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8829;}}}}}}}}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10928;}}}s:1:"n";a:3:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10938;}}}}}}}s:1:"e";a:1:{s:1:"q";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10934;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8937;}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8831;}}}}}}s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8721;}}s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9834;}}}s:1:"p";a:13:{i:1;a:2:{s:1:";";a:1:{s:9:"codepoint";i:185;}s:9:"codepoint";i:185;}i:2;a:2:{s:1:";";a:1:{s:9:"codepoint";i:178;}s:9:"codepoint";i:178;}i:3;a:2:{s:1:";";a:1:{s:9:"codepoint";i:179;}s:9:"codepoint";i:179;}s:1:";";a:1:{s:9:"codepoint";i:8835;}s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10950;}}s:1:"d";a:2:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10942;}}}s:1:"s";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10968;}}}}}s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8839;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10948;}}}}}s:1:"h";a:1:{s:1:"s";a:1:{s:1:"u";a:1:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10967;}}}}}s:1:"l";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10619;}}}}}s:1:"m";a:1:{s:1:"u";a:1:{s:1:"l";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10946;}}}}}s:1:"n";a:2:{s:1:"E";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10956;}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8843;}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10944;}}}}}s:1:"s";a:3:{s:1:"e";a:1:{s:1:"t";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8835;}s:1:"e";a:1:{s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8839;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10950;}}}}s:1:"n";a:1:{s:1:"e";a:1:{s:1:"q";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8843;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10956;}}}}}}}s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10952;}}}s:1:"u";a:2:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10964;}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10966;}}}}}}s:1:"w";a:3:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8665;}}}}s:1:"a";a:1:{s:1:"r";a:2:{s:1:"h";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10534;}}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8601;}s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8601;}}}}}}s:1:"n";a:1:{s:1:"w";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10538;}}}}}}s:1:"z";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"g";a:2:{s:1:";";a:1:{s:9:"codepoint";i:223;}s:9:"codepoint";i:223;}}}}}s:1:"t";a:13:{s:1:"a";a:2:{s:1:"r";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8982;}}}}}s:1:"u";a:1:{s:1:";";a:1:{s:9:"codepoint";i:964;}}}s:1:"b";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9140;}}}}s:1:"c";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:357;}}}}}s:1:"e";a:1:{s:1:"d";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:355;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1090;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8411;}}}}s:1:"e";a:1:{s:1:"l";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8981;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120113;}}}s:1:"h";a:4:{s:1:"e";a:2:{s:1:"r";a:1:{s:1:"e";a:2:{i:4;a:1:{s:1:";";a:1:{s:9:"codepoint";i:8756;}}s:1:"f";a:1:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8756;}}}}}}}s:1:"t";a:1:{s:1:"a";a:3:{s:1:";";a:1:{s:9:"codepoint";i:952;}s:1:"s";a:1:{s:1:"y";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:977;}}}}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:977;}}}}}s:1:"i";a:2:{s:1:"c";a:1:{s:1:"k";a:2:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"x";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8776;}}}}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8764;}}}}}}s:1:"n";a:1:{s:1:"s";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8201;}}}}}s:1:"k";a:2:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8776;}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8764;}}}}}s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:254;}s:9:"codepoint";i:254;}}}}s:1:"i";a:3:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:732;}}}}s:1:"m";a:1:{s:1:"e";a:1:{s:1:"s";a:4:{s:1:";";a:1:{s:9:"codepoint";i:215;}s:9:"codepoint";i:215;s:1:"b";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8864;}s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10801;}}}}s:1:"d";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10800;}}}}}s:1:"n";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8749;}}}}s:1:"o";a:3:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10536;}}}s:1:"p";a:4:{s:1:";";a:1:{s:9:"codepoint";i:8868;}s:1:"b";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9014;}}}}s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10993;}}}}s:1:"f";a:2:{s:1:";";a:1:{s:9:"codepoint";i:120165;}s:1:"o";a:1:{s:1:"r";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10970;}}}}}}s:1:"s";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10537;}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8244;}}}}}}s:1:"r";a:3:{s:1:"a";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8482;}}}}s:1:"i";a:7:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:5:{s:1:";";a:1:{s:9:"codepoint";i:9653;}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9663;}}}}}s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9667;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8884;}}}}}}}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8796;}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9657;}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8885;}}}}}}}}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9708;}}}}s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8796;}}s:1:"m";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10810;}}}}}}s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10809;}}}}}s:1:"s";a:1:{s:1:"b";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10701;}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10811;}}}}}}s:1:"p";a:1:{s:1:"e";a:1:{s:1:"z";a:1:{s:1:"i";a:1:{s:1:"u";a:1:{s:1:"m";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9186;}}}}}}}}s:1:"s";a:3:{s:1:"c";a:2:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120009;}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1094;}}}s:1:"h";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1115;}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:359;}}}}}}s:1:"w";a:2:{s:1:"i";a:1:{s:1:"x";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8812;}}}}s:1:"o";a:1:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:"a";a:1:{s:1:"d";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8606;}}}}}}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8608;}}}}}}}}}}}}}}}}}}s:1:"u";a:18:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8657;}}}}s:1:"H";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10595;}}}}s:1:"a";a:2:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:250;}s:9:"codepoint";i:250;}}}}s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8593;}}}}s:1:"b";a:1:{s:1:"r";a:2:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1118;}}}s:1:"e";a:1:{s:1:"v";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:365;}}}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:2:{s:1:";";a:1:{s:9:"codepoint";i:251;}s:9:"codepoint";i:251;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1091;}}}s:1:"d";a:3:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8645;}}}}s:1:"b";a:1:{s:1:"l";a:1:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:369;}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10606;}}}}}s:1:"f";a:2:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10622;}}}}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120114;}}}s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"v";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:249;}s:9:"codepoint";i:249;}}}}}s:1:"h";a:2:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:"l";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8639;}}s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8638;}}}}s:1:"b";a:1:{s:1:"l";a:1:{s:1:"k";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9600;}}}}}s:1:"l";a:2:{s:1:"c";a:2:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8988;}s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8988;}}}}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8975;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9720;}}}}}s:1:"m";a:2:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:363;}}}}s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:168;}s:9:"codepoint";i:168;}}s:1:"o";a:2:{s:1:"g";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:371;}}}}s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120166;}}}}s:1:"p";a:6:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8593;}}}}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"n";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8597;}}}}}}}}}}s:1:"h";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:"o";a:1:{s:1:"o";a:1:{s:1:"n";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8639;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8638;}}}}}}}}}}}}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8846;}}}}s:1:"s";a:1:{s:1:"i";a:3:{s:1:";";a:1:{s:9:"codepoint";i:965;}s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:978;}}s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:965;}}}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"w";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8648;}}}}}}}}}}s:1:"r";a:3:{s:1:"c";a:2:{s:1:"o";a:1:{s:1:"r";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8989;}s:1:"e";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8989;}}}}}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8974;}}}}}s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:367;}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9721;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120010;}}}}s:1:"t";a:3:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8944;}}}}s:1:"i";a:1:{s:1:"l";a:1:{s:1:"d";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:361;}}}}}s:1:"r";a:1:{s:1:"i";a:2:{s:1:";";a:1:{s:9:"codepoint";i:9653;}s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9652;}}}}}s:1:"u";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8648;}}}}s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:252;}s:9:"codepoint";i:252;}}}s:1:"w";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10663;}}}}}}}}s:1:"v";a:14:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8661;}}}}s:1:"B";a:1:{s:1:"a";a:1:{s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:10984;}s:1:"v";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10985;}}}}}s:1:"D";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8872;}}}}}s:1:"a";a:2:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10652;}}}}}s:1:"r";a:7:{s:1:"e";a:1:{s:1:"p";a:1:{s:1:"s";a:1:{s:1:"i";a:1:{s:1:"l";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:949;}}}}}}}}s:1:"k";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:"p";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1008;}}}}}}s:1:"n";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:"i";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8709;}}}}}}}}s:1:"p";a:3:{s:1:"h";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:966;}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:982;}}s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:"t";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8733;}}}}}}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8597;}s:1:"h";a:1:{s:1:"o";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1009;}}}}s:1:"s";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"m";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:962;}}}}}}s:1:"t";a:2:{s:1:"h";a:1:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:977;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"a";a:1:{s:1:"n";a:1:{s:1:"g";a:1:{s:1:"l";a:1:{s:1:"e";a:2:{s:1:"l";a:1:{s:1:"e";a:1:{s:1:"f";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8882;}}}}}s:1:"r";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"h";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8883;}}}}}}}}}}}}}}}}s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1074;}}}s:1:"d";a:1:{s:1:"a";a:1:{s:1:"s";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8866;}}}}}s:1:"e";a:3:{s:1:"e";a:3:{s:1:";";a:1:{s:9:"codepoint";i:8744;}s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8891;}}}}s:1:"e";a:1:{s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8794;}}}}s:1:"l";a:1:{s:1:"l";a:1:{s:1:"i";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8942;}}}}}s:1:"r";a:2:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:124;}}}}s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:124;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120115;}}}s:1:"l";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8882;}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120167;}}}}s:1:"p";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8733;}}}}}s:1:"r";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8883;}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120011;}}}}s:1:"z";a:1:{s:1:"i";a:1:{s:1:"g";a:1:{s:1:"z";a:1:{s:1:"a";a:1:{s:1:"g";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10650;}}}}}}}}s:1:"w";a:7:{s:1:"c";a:1:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:373;}}}}}s:1:"e";a:2:{s:1:"d";a:2:{s:1:"b";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10847;}}}}s:1:"g";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8743;}s:1:"q";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8793;}}}}}s:1:"i";a:1:{s:1:"e";a:1:{s:1:"r";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8472;}}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120116;}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120168;}}}}s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8472;}}s:1:"r";a:2:{s:1:";";a:1:{s:9:"codepoint";i:8768;}s:1:"e";a:1:{s:1:"a";a:1:{s:1:"t";a:1:{s:1:"h";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8768;}}}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120012;}}}}}s:1:"x";a:14:{s:1:"c";a:3:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8898;}}}s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9711;}}}}s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8899;}}}}s:1:"d";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9661;}}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120117;}}}s:1:"h";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10234;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10231;}}}}}s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:958;}}s:1:"l";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10232;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10229;}}}}}s:1:"m";a:1:{s:1:"a";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10236;}}}}s:1:"n";a:1:{s:1:"i";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8955;}}}}s:1:"o";a:3:{s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10752;}}}}s:1:"p";a:2:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120169;}}s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10753;}}}}}s:1:"t";a:1:{s:1:"i";a:1:{s:1:"m";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10754;}}}}}}s:1:"r";a:2:{s:1:"A";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10233;}}}}s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10230;}}}}}s:1:"s";a:2:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120013;}}}s:1:"q";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"p";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10758;}}}}}}s:1:"u";a:2:{s:1:"p";a:1:{s:1:"l";a:1:{s:1:"u";a:1:{s:1:"s";a:1:{s:1:";";a:1:{s:9:"codepoint";i:10756;}}}}}s:1:"t";a:1:{s:1:"r";a:1:{s:1:"i";a:1:{s:1:";";a:1:{s:9:"codepoint";i:9651;}}}}}s:1:"v";a:1:{s:1:"e";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8897;}}}}s:1:"w";a:1:{s:1:"e";a:1:{s:1:"d";a:1:{s:1:"g";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8896;}}}}}}}s:1:"y";a:8:{s:1:"a";a:1:{s:1:"c";a:2:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:2:{s:1:";";a:1:{s:9:"codepoint";i:253;}s:9:"codepoint";i:253;}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1103;}}}}s:1:"c";a:2:{s:1:"i";a:1:{s:1:"r";a:1:{s:1:"c";a:1:{s:1:";";a:1:{s:9:"codepoint";i:375;}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1099;}}}s:1:"e";a:1:{s:1:"n";a:2:{s:1:";";a:1:{s:9:"codepoint";i:165;}s:9:"codepoint";i:165;}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120118;}}}s:1:"i";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1111;}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120170;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120014;}}}}s:1:"u";a:2:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1102;}}}s:1:"m";a:1:{s:1:"l";a:2:{s:1:";";a:1:{s:9:"codepoint";i:255;}s:9:"codepoint";i:255;}}}}s:1:"z";a:10:{s:1:"a";a:1:{s:1:"c";a:1:{s:1:"u";a:1:{s:1:"t";a:1:{s:1:"e";a:1:{s:1:";";a:1:{s:9:"codepoint";i:378;}}}}}}s:1:"c";a:2:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"o";a:1:{s:1:"n";a:1:{s:1:";";a:1:{s:9:"codepoint";i:382;}}}}}s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1079;}}}s:1:"d";a:1:{s:1:"o";a:1:{s:1:"t";a:1:{s:1:";";a:1:{s:9:"codepoint";i:380;}}}}s:1:"e";a:2:{s:1:"e";a:1:{s:1:"t";a:1:{s:1:"r";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8488;}}}}}s:1:"t";a:1:{s:1:"a";a:1:{s:1:";";a:1:{s:9:"codepoint";i:950;}}}}s:1:"f";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120119;}}}s:1:"h";a:1:{s:1:"c";a:1:{s:1:"y";a:1:{s:1:";";a:1:{s:9:"codepoint";i:1078;}}}}s:1:"i";a:1:{s:1:"g";a:1:{s:1:"r";a:1:{s:1:"a";a:1:{s:1:"r";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8669;}}}}}}}s:1:"o";a:1:{s:1:"p";a:1:{s:1:"f";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120171;}}}}s:1:"s";a:1:{s:1:"c";a:1:{s:1:"r";a:1:{s:1:";";a:1:{s:9:"codepoint";i:120015;}}}}s:1:"w";a:2:{s:1:"j";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8205;}}s:1:"n";a:1:{s:1:"j";a:1:{s:1:";";a:1:{s:9:"codepoint";i:8204;}}}}}}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/humble-http-agent/CookieJar.php b/inc/3rdparty/libraries/humble-http-agent/CookieJar.php
new file mode 100644
index 00000000..83e94f14
--- /dev/null
+++ b/inc/3rdparty/libraries/humble-http-agent/CookieJar.php
@@ -0,0 +1,404 @@
+<?php

+/**

+ * Cookie Jar

+ * 

+ * PHP class for handling cookies, as defined by the Netscape spec: 

+ * <http://curl.haxx.se/rfc/cookie_spec.html>

+ *

+ * This class should be used to handle cookies (storing cookies from HTTP response messages, and

+ * sending out cookies in HTTP request messages). This has been adapted for FiveFilters.org 

+ * from the original version used in HTTP Navigator. See http://www.keyvan.net/code/http-navigator/

+ * 

+ * This class is mainly based on Cookies.pm <http://search.cpan.org/author/GAAS/libwww-perl-5.65/

+ * lib/HTTP/Cookies.pm> from the libwww-perl collection <http://www.linpro.no/lwp/>.

+ * Unlike Cookies.pm, this class only supports the Netscape cookie spec, not RFC 2965.

+ * 

+ * @version 0.5

+ * @date 2011-03-15

+ * @see http://php.net/HttpRequestPool

+ * @author Keyvan Minoukadeh

+ * @copyright 2011 Keyvan Minoukadeh

+ * @license http://www.gnu.org/licenses/agpl-3.0.html AGPL v3

+ */

+

+class CookieJar

+{

+    /**

+    * Cookies - array containing all cookies.

+    *

+    * <pre>

+    * Cookies are stored like this:

+    *   [domain][path][name] = array

+    * where array is:

+    *   0 => value, 1 => secure, 2 => expires

+    * </pre>

+    * @var array

+    * @access private

+    */

+    public $cookies = array();

+        public $debug = false;

+

+    /**

+    * Constructor

+    */

+    function __construct() {

+    }

+

+        protected function debug($msg, $file=null, $line=null) {

+                if ($this->debug) {

+                        $mem = round(memory_get_usage()/1024, 2);

+                        $memPeak = round(memory_get_peak_usage()/1024, 2);

+                        echo '* ',$msg;

+                        if (isset($file, $line)) echo " ($file line $line)";

+                        echo ' - mem used: ',$mem," (peak: $memPeak)\n";        

+                        ob_flush();

+                        flush();

+                }

+        }       

+        

+    /**

+    * Get matching cookies

+    *

+    * Only use this method if you cannot use add_cookie_header(), for example, if you want to use

+    * this cookie jar class without using the request class.

+    *

+    * @param array $param associative array containing 'domain', 'path', 'secure' keys

+    * @return string

+    * @see add_cookie_header()

+    */

+    public function getMatchingCookies($url)

+    {

+                if (($parts = @parse_url($url)) && isset($parts['scheme'], $parts['host'], $parts['path'])) {

+                        $param['domain'] = $parts['host'];

+                        $param['path'] = $parts['path'];

+                        $param['secure'] = (strtolower($parts['scheme']) == 'https');

+                        unset($parts);

+                } else {

+                        return false;

+                }

+        // RFC 2965 notes:

+        //  If multiple cookies satisfy the criteria above, they are ordered in

+        //  the Cookie header such that those with more specific Path attributes

+        //  precede those with less specific.  Ordering with respect to other

+        //  attributes (e.g., Domain) is unspecified.

+        $domain = $param['domain'];

+        if (strpos($domain, '.') === false) $domain .= '.local';

+        $request_path = $param['path'];

+        if ($request_path == '') $request_path = '/';

+        $request_secure = $param['secure'];

+        $now = time();

+        $matched_cookies = array();

+        // domain - find matching domains

+        $this->debug('Finding matching domains for '.$domain, __FILE__, __LINE__);

+        while (strpos($domain, '.') !== false) {

+            if (isset($this->cookies[$domain])) {

+                $this->debug(' domain match found: '.$domain);

+                $cookies =& $this->cookies[$domain];

+            } else {

+                $domain = $this->_reduce_domain($domain);

+                continue;

+            }

+            // paths - find matching paths starting from most specific

+            $this->debug('  - Finding matching paths for '.$request_path);

+            $paths = array_keys($cookies);

+            usort($paths, array($this, '_cmp_length'));

+            foreach ($paths as $path) {

+                // continue to next cookie if request path does not path-match cookie path

+                if (!$this->_path_match($request_path, $path)) continue;

+                // loop through cookie names

+                $this->debug('     path match found: '.$path);

+                foreach ($cookies[$path] as $name => $values) {

+                    // if this cookie is secure but request isn't, continue to next cookie

+                    if ($values[1] && !$request_secure) continue;

+                    // if cookie is not a session cookie and has expired, continue to next cookie

+                    if (is_int($values[2]) && ($values[2] < $now)) continue;

+                    // cookie matches request

+                    $this->debug('      cookie match: '.$name.'='.$values[0]);

+                    $matched_cookies[] = $name.'='.$values[0];

+                }

+            }

+            $domain = $this->_reduce_domain($domain);

+        }

+        // return cookies

+        return implode('; ', $matched_cookies);

+    }

+

+    /**

+    * Parse Set-Cookie values.

+    *

+    * Only use this method if you cannot use extract_cookies(), for example, if you want to use

+    * this cookie jar class without using the response class.

+    *

+    * @param array $set_cookies array holding 1 or more "Set-Cookie" header values

+    * @param array $param associative array containing 'host', 'path' keys

+    * @return void

+    * @see extract_cookies()

+    */

+    public function storeCookies($url, $set_cookies)

+    {

+        if (count($set_cookies) == 0) return;

+                $param = @parse_url($url);

+                if (!is_array($param) || !isset($param['host'])) return;

+        $request_host = $param['host'];

+        if (strpos($request_host, '.') === false) $request_host .= '.local';

+        $request_path = @$param['path'];

+        if ($request_path == '') $request_path = '/';

+        //

+        // loop through set-cookie headers

+        //

+        foreach ($set_cookies as $set_cookie) {

+            $this->debug('Parsing: '.$set_cookie);

+            // temporary cookie store (before adding to jar)

+            $tmp_cookie = array();

+            $param = explode(';', $set_cookie);

+            // loop through params

+            for ($x=0; $x<count($param); $x++) {

+                $key_val = explode('=', $param[$x], 2);

+                if (count($key_val) != 2) {

+                    // if the first param isn't a name=value pair, continue to the next set-cookie

+                    // header

+                    if ($x == 0) continue 2;

+                    // check for secure flag

+                    if (strtolower(trim($key_val[0])) == 'secure') $tmp_cookie['secure'] = true;

+                    // continue to next param

+                    continue;

+                }

+                list($key, $val) = array_map('trim', $key_val);

+                // first name=value pair is the cookie name and value

+                // the name and value are stored under 'name' and 'value' to avoid conflicts

+                // with later parameters.

+                if ($x == 0) {

+                    $tmp_cookie = array('name'=>$key, 'value'=>$val);

+                    continue;

+                }

+                $key = strtolower($key);

+                if (in_array($key, array('expires', 'path', 'domain', 'secure'))) {

+                    $tmp_cookie[$key] = $val;

+                }

+            }

+            //

+            // set cookie

+            //

+            // check domain

+            if (isset($tmp_cookie['domain']) && ($tmp_cookie['domain'] != $request_host) &&

+                    ($tmp_cookie['domain'] != ".$request_host")) {

+                $domain = $tmp_cookie['domain'];

+                if ((strpos($domain, '.') === false) && ($domain != 'local')) {

+                    $this->debug(' - domain "'.$domain.'" has no dot and is not a local domain');

+                    continue;

+                }

+                if (preg_match('/\.[0-9]+$/', $domain)) {

+                    $this->debug(' - domain "'.$domain.'" appears to be an ip address');

+                    continue;

+                }

+                if (substr($domain, 0, 1) != '.') $domain = ".$domain";

+                if (!$this->_domain_match($request_host, $domain)) {

+                    $this->debug(' - request host "'.$request_host.'" does not domain-match "'.$domain.'"');

+                    continue;

+                }

+            } else {

+                // if domain is not specified in the set-cookie header, domain will default to

+                // the request host

+                $domain = $request_host;

+            }

+            // check path

+            if (isset($tmp_cookie['path']) && ($tmp_cookie['path'] != '')) {

+                $path = urldecode($tmp_cookie['path']);

+                if (!$this->_path_match($request_path, $path)) {

+                    $this->debug(' - request path "'.$request_path.'" does not path-match "'.$path.'"');

+                    continue;

+                }

+            } else {

+                $path = $request_path;

+                $path = substr($path, 0, strrpos($path, '/'));

+                if ($path == '') $path = '/';

+            }

+            // check if secure

+            $secure = (isset($tmp_cookie['secure'])) ? true : false;

+            // check expiry

+            if (isset($tmp_cookie['expires'])) {

+                if (($expires = strtotime($tmp_cookie['expires'])) < 0) {

+                    $expires = null;

+                }

+            } else {

+                $expires = null;

+            }

+            // set cookie

+            $this->set_cookie($domain, $path, $tmp_cookie['name'], $tmp_cookie['value'], $secure, $expires);

+        }

+    }

+        

+        // return array of set-cookie values extracted from HTTP response headers (string $h)

+        public function extractCookies($h) {

+        $x = 0;

+        $lines = 0;

+        $headers = array();

+        $last_match = false;

+                $h = explode("\n", $h);

+        foreach ($h as $line) {

+                        $line = rtrim($line);

+            $lines++;

+

+            $trimmed_line = trim($line);

+            if (isset($line_last)) {

+                // check if we have \r\n\r\n (indicating the end of headers)

+                // some servers will not use CRLF (\r\n), so we make CR (\r) optional.

+                // if (preg_match('/\015?\012\015?\012/', $line_last.$line)) {

+                //     break;

+                // }

+                // As an alternative, we can check if the current trimmed line is empty

+                if ($trimmed_line == '') {

+                    break;

+                }

+

+                // check for continuation line...

+                // RFC 2616 Section 2.2 "Basic Rules":

+                // HTTP/1.1 header field values can be folded onto multiple lines if the

+                // continuation line begins with a space or horizontal tab. All linear

+                // white space, including folding, has the same semantics as SP. A

+                // recipient MAY replace any linear white space with a single SP before

+                // interpreting the field value or forwarding the message downstream.

+                if ($last_match && preg_match('/^\s+(.*)/', $line, $match)) {

+                    // append to previous header value

+                    $headers[$x-1] .= ' '.rtrim($match[1]);

+                    continue;

+                }

+            }

+            $line_last = $line;

+

+            // split header name and value

+            if (preg_match('/^Set-Cookie\s*:\s*(.*)/i', $line, $match)) {

+                $headers[$x++] = rtrim($match[1]);

+                $last_match = true;

+            } else {

+                $last_match = false;

+            }

+        }

+        return $headers;

+        }

+

+    /**

+    * Set Cookie

+    * @param string $domain

+    * @param string $path

+    * @param string $name cookie name

+    * @param string $value cookie value

+    * @param bool $secure

+    * @param int $expires expiry time (null if session cookie, <= 0 will delete cookie)

+    * @return void

+    */

+    function set_cookie($domain, $path, $name, $value, $secure=false, $expires=null)

+    {

+        if ($domain == '') return;

+        if ($path == '') return;

+        if ($name == '') return;

+        // check if cookie needs to go

+        if (isset($expires) && ($expires <= 0)) {

+            if (isset($this->cookies[$domain][$path][$name])) unset($this->cookies[$domain][$path][$name]);

+            return;

+        }

+        if ($value == '') return;

+        $this->cookies[$domain][$path][$name] = array($value, $secure, $expires);

+        return;

+    }

+

+    /**

+    * Clear cookies - [domain [,path [,name]]] - call method with no arguments to clear all cookies.

+    * @param string $domain

+    * @param string $path

+    * @param string $name

+    * @return void

+    */

+    function clear($domain=null, $path=null, $name=null)

+    {

+        if (!isset($domain)) {

+            $this->cookies = array();

+        } elseif (!isset($path)) {

+            if (isset($this->cookies[$domain])) unset($this->cookies[$domain]);

+        } elseif (!isset($name)) {

+            if (isset($this->cookies[$domain][$path])) unset($this->cookies[$domain][$path]);

+        } elseif (isset($name)) {

+            if (isset($this->cookies[$domain][$path][$name])) unset($this->cookies[$domain][$path][$name]);

+        }

+    }

+

+    /**

+    * Compare string length - used for sorting

+    * @access private

+    * @return int

+    */

+    function _cmp_length($a, $b)

+    {

+        $la = strlen($a); $lb = strlen($b);

+        if ($la == $lb) return 0;

+        return ($la > $lb) ? -1 : 1;

+    }

+

+    /**

+    * Reduce domain

+    * @param string $domain

+    * @return string

+    * @access private

+    */

+    function _reduce_domain($domain)

+    {

+        if ($domain == '') return '';

+        if (substr($domain, 0, 1) == '.') return substr($domain, 1);

+        return substr($domain, strpos($domain, '.'));

+    }

+

+    /**

+    * Path match - check if path1 path-matches path2

+    *

+    * From RFC 2965: 

+    *   <i>For two strings that represent paths, P1 and P2, P1 path-matches P2

+    *   if P2 is a prefix of P1 (including the case where P1 and P2 string-

+    *   compare equal).  Thus, the string /tec/waldo path-matches /tec.</i>

+    * @param string $path1

+    * @param string $path2

+    * @return bool

+    * @access private

+    */

+    function _path_match($path1, $path2)

+    {

+        return (substr($path1, 0, strlen($path2)) == $path2);

+    }

+

+    /**

+    * Domain match - check if domain1 domain-matches domain2

+    *

+    * A few extracts from RFC 2965: 

+    *  -  A Set-Cookie2 from request-host y.x.foo.com for Domain=.foo.com

+    *     would be rejected, because H is y.x and contains a dot.

+    *

+    *  -  A Set-Cookie2 from request-host x.foo.com for Domain=.foo.com

+    *     would be accepted.

+    *

+    *  -  A Set-Cookie2 with Domain=.com or Domain=.com., will always be

+    *     rejected, because there is no embedded dot.

+    *

+    *  -  A Set-Cookie2 from request-host example for Domain=.local will

+    *     be accepted, because the effective host name for the request-

+    *     host is example.local, and example.local domain-matches .local.

+    *

+    * I'm ignoring the first point for now (must check to see how other browsers handle

+    * this rule for Set-Cookie headers)

+    *

+    * @param string $domain1

+    * @param string $domain2

+    * @return bool

+    * @access private

+    */

+    function _domain_match($domain1, $domain2)

+    {

+        $domain1 = strtolower($domain1);

+        $domain2 = strtolower($domain2);

+        while (strpos($domain1, '.') !== false) {

+            if ($domain1 == $domain2) return true;

+            $domain1 = $this->_reduce_domain($domain1);

+            continue;

+        }

+        return false;

+    }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/humble-http-agent/HumbleHttpAgent.php b/inc/3rdparty/libraries/humble-http-agent/HumbleHttpAgent.php
new file mode 100644
index 00000000..e4f1b3b3
--- /dev/null
+++ b/inc/3rdparty/libraries/humble-http-agent/HumbleHttpAgent.php
@@ -0,0 +1,779 @@
+<?php

+/**

+ * Humble HTTP Agent

+ * 

+ * This class is designed to take advantage of parallel HTTP requests

+ * offered by PHP's PECL HTTP extension or the curl_multi_* functions. 

+ * For environments which do not have these options, it reverts to standard sequential 

+ * requests (using file_get_contents())

+ * 

+ * @version 1.1

+ * @date 2012-08-20

+ * @see http://php.net/HttpRequestPool

+ * @author Keyvan Minoukadeh

+ * @copyright 2011-2012 Keyvan Minoukadeh

+ * @license http://www.gnu.org/licenses/agpl-3.0.html AGPL v3

+ */

+

+class HumbleHttpAgent

+{

+        const METHOD_REQUEST_POOL = 1;

+        const METHOD_CURL_MULTI = 2;

+        const METHOD_FILE_GET_CONTENTS = 4;

+        //const UA_BROWSER = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:2.0.1) Gecko/20100101 Firefox/4.0.1';

+        const UA_BROWSER = 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.874.92 Safari/535.2';

+        const UA_PHP = 'PHP/5.2';

+        const REF_GOOGLE = 'http://www.google.co.uk/url?sa=t&source=web&cd=1';

+        

+        protected $requests = array();

+        protected $redirectQueue = array();

+        protected $requestOptions;

+        protected $maxParallelRequests = 5;

+        protected $cache = null; //TODO

+        protected $httpContext;

+        protected $minimiseMemoryUse = false; //TODO

+        protected $method;

+        protected $cookieJar;

+        public $debug = false;

+        public $debugVerbose = false;

+        public $rewriteHashbangFragment = true; // see http://code.google.com/web/ajaxcrawling/docs/specification.html

+        public $maxRedirects = 5;

+        public $userAgentMap = array();

+        public $rewriteUrls = array();

+        public $userAgentDefault;

+        public $referer;

+        //public $userAgent = 'Mozilla/5.0';

+        

+        // Prevent certain file/mime types

+        // HTTP responses which match these content types will

+        // be returned without body.

+        public $headerOnlyTypes = array();

+        // URLs ending with one of these extensions will

+        // prompt Humble HTTP Agent to send a HEAD request first

+        // to see if returned content type matches $headerOnlyTypes.

+        public $headerOnlyClues = array('pdf','mp3','zip','exe','gif','gzip','gz','jpeg','jpg','mpg','mpeg','png','ppt','mov');

+        // AJAX triggers to search for.

+        // for AJAX sites, e.g. Blogger with its dynamic views templates.

+        public $ajaxTriggers = array("<meta name='fragment' content='!'",'<meta name="fragment" content="!"',"<meta content='!' name='fragment'",'<meta content="!" name="fragment"');

+        

+        //TODO: set max file size

+        //TODO: normalise headers

+        

+        function __construct($requestOptions=null, $method=null) {

+                $this->userAgentDefault = self::UA_BROWSER;

+                $this->referer = self::REF_GOOGLE;

+                // set the request method

+                if (in_array($method, array(1,2,4))) {

+                        $this->method = $method;

+                } else {

+                        if (class_exists('HttpRequestPool')) {

+                                $this->method = self::METHOD_REQUEST_POOL;

+                        } elseif (function_exists('curl_multi_init')) {

+                                $this->method = self::METHOD_CURL_MULTI;

+                        } else {

+                                $this->method = self::METHOD_FILE_GET_CONTENTS;

+                        }

+                }

+                if ($this->method == self::METHOD_CURL_MULTI) {

+                        require_once(dirname(__FILE__).'/RollingCurl.php');

+                }

+                // create cookie jar

+                $this->cookieJar = new CookieJar();

+                // set request options (redirect must be 0)

+                $this->requestOptions = array(

+                        'timeout' => 15,

+                        'redirect' => 0 // we handle redirects manually so we can rewrite the new hashbang URLs that are creeping up over the web

+                        // TODO: test onprogress?

+                );

+                if (is_array($requestOptions)) {

+                        $this->requestOptions = array_merge($this->requestOptions, $requestOptions);

+                }

+                $this->httpContext = array(

+                        'http' => array(

+                                'ignore_errors' => true,

+                                'timeout' => $this->requestOptions['timeout'],

+                                'max_redirects' => $this->requestOptions['redirect'],

+                                'header' => "Accept: */*\r\n"

+                                )

+                        );

+        }

+        

+        protected function debug($msg) {

+                if ($this->debug) {

+                        $mem = round(memory_get_usage()/1024, 2);

+                        $memPeak = round(memory_get_peak_usage()/1024, 2);

+                        echo '* ',$msg;

+                        if ($this->debugVerbose) echo ' - mem used: ',$mem," (peak: $memPeak)";

+                        echo "\n";

+                        ob_flush();

+                        flush();

+                }

+        }

+        

+        protected function getUserAgent($url, $asArray=false) {

+                $host = @parse_url($url, PHP_URL_HOST);

+                if (strtolower(substr($host, 0, 4)) == 'www.') {

+                        $host = substr($host, 4);

+                }

+                if ($host) {

+                        $try = array($host);

+                        $split = explode('.', $host);

+                        if (count($split) > 1) {

+                                array_shift($split);

+                                $try[] = '.'.implode('.', $split);

+                        }

+                        foreach ($try as $h) {

+                                if (isset($this->userAgentMap[$h])) {

+                                        $ua = $this->userAgentMap[$h];

+                                        break;

+                                }

+                        }

+                }

+                if (!isset($ua)) $ua = $this->userAgentDefault;

+                if ($asArray) {

+                        return array('User-Agent' => $ua);

+                } else {

+                        return 'User-Agent: '.$ua;

+                }

+        }

+        

+        public function rewriteHashbangFragment($url) {

+                // return $url if there's no '#!'

+                if (strpos($url, '#!') === false) return $url;

+                // split $url and rewrite

+                // TODO: is SimplePie_IRI included?

+                $iri = new SimplePie_IRI($url);

+                $fragment = substr($iri->fragment, 1); // strip '!'

+                $iri->fragment = null;

+                if (isset($iri->query)) {

+                        parse_str($iri->query, $query);

+                } else {

+                        $query = array();

+                }

+                $query['_escaped_fragment_'] = (string)$fragment;

+                $iri->query = str_replace('%2F', '/', http_build_query($query)); // needed for some sites

+                return $iri->get_iri();

+        }

+        

+        public function getUglyURL($url, $html) {

+                if ($html == '') return false;

+                $found = false;

+                foreach ($this->ajaxTriggers as $string) {

+                        if (stripos($html, $string)) {

+                                $found = true;

+                                break;

+                        }

+                }

+                if (!$found) return false;

+                $iri = new SimplePie_IRI($url);

+                if (isset($iri->query)) {

+                        parse_str($iri->query, $query);

+                } else {

+                        $query = array();

+                }

+                $query['_escaped_fragment_'] = '';

+                $iri->query = str_replace('%2F', '/', http_build_query($query)); // needed for some sites

+                return $iri->get_iri();

+        }

+        

+        public function removeFragment($url) {

+                $pos = strpos($url, '#');

+                if ($pos === false) {

+                        return $url;

+                } else {

+                        return substr($url, 0, $pos);

+                }

+        }

+        

+        public function rewriteUrls($url) {

+                foreach ($this->rewriteUrls as $find => $action) {

+                        if (strpos($url, $find) !== false) {

+                                if (is_array($action)) {

+                                        return strtr($url, $action);

+                                }

+                        }

+                }

+                return $url;

+        }

+        

+        public function enableDebug($bool=true) {

+                $this->debug = (bool)$bool;

+        }

+        

+        public function minimiseMemoryUse($bool = true) {

+                $this->minimiseMemoryUse = $bool;

+        }

+        

+        public function setMaxParallelRequests($max) {

+                $this->maxParallelRequests = $max;

+        }

+        

+        public function validateUrl($url) {

+                $url = filter_var($url, FILTER_SANITIZE_URL);

+                $test = filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED);

+                // deal with bug http://bugs.php.net/51192 (present in PHP 5.2.13 and PHP 5.3.2)

+                if ($test === false) {

+                        $test = filter_var(strtr($url, '-', '_'), FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED);

+                }

+                if ($test !== false && $test !== null && preg_match('!^https?://!', $url)) {

+                        return $url;

+                } else {

+                        return false;

+                }

+        }

+        

+        public function fetchAll(array $urls) {

+                $this->fetchAllOnce($urls, $isRedirect=false);

+                $redirects = 0;

+                while (!empty($this->redirectQueue) && ++$redirects <= $this->maxRedirects) {

+                        $this->debug("Following redirects #$redirects...");

+                        $this->fetchAllOnce($this->redirectQueue, $isRedirect=true);

+                }

+        }

+        

+        // fetch all URLs without following redirects

+        public function fetchAllOnce(array $urls, $isRedirect=false) {

+                if (!$isRedirect) $urls = array_unique($urls);

+                if (empty($urls)) return;

+                

+                //////////////////////////////////////////////////////

+                // parallel (HttpRequestPool)

+                if ($this->method == self::METHOD_REQUEST_POOL) {

+                        $this->debug('Starting parallel fetch (HttpRequestPool)');

+                        try {

+                                while (count($urls) > 0) {

+                                        $this->debug('Processing set of '.min($this->maxParallelRequests, count($urls)));

+                                        $subset = array_splice($urls, 0, $this->maxParallelRequests);

+                                        $pool = new HttpRequestPool();

+                                        foreach ($subset as $orig => $url) {

+                                                if (!$isRedirect) $orig = $url;

+                                                unset($this->redirectQueue[$orig]);

+                                                $this->debug("...$url");

+                                                if (!$isRedirect && isset($this->requests[$url])) {

+                                                        $this->debug("......in memory");

+                                                /*

+                                                } elseif ($this->isCached($url)) {

+                                                        $this->debug("......is cached");

+                                                        if (!$this->minimiseMemoryUse) {

+                                                                $this->requests[$url] = $this->getCached($url);

+                                                        }

+                                                */

+                                                } else {

+                                                        $this->debug("......adding to pool");

+                                                        $req_url = $this->rewriteUrls($url);

+                                                        $req_url = ($this->rewriteHashbangFragment) ? $this->rewriteHashbangFragment($req_url) : $req_url;

+                                                        $req_url = $this->removeFragment($req_url);

+                                                        if (!empty($this->headerOnlyTypes) && !isset($this->requests[$orig]['wrongGuess']) && $this->possibleUnsupportedType($req_url)) {

+                                                                $_meth = HttpRequest::METH_HEAD;

+                                                        } else {

+                                                                $_meth = HttpRequest::METH_GET;

+                                                                unset($this->requests[$orig]['wrongGuess']);

+                                                        }

+                                                        $httpRequest = new HttpRequest($req_url, $_meth, $this->requestOptions);

+                                                        // send cookies, if we have any

+                                                        if ($cookies = $this->cookieJar->getMatchingCookies($req_url)) {

+                                                                $this->debug("......sending cookies: $cookies");

+                                                                $httpRequest->addHeaders(array('Cookie' => $cookies));

+                                                        }

+                                                        //$httpRequest->addHeaders(array('User-Agent' => $this->userAgent));

+                                                        $httpRequest->addHeaders($this->getUserAgent($req_url, true));

+                                                        // add referer for picky sites

+                                                        $httpRequest->addheaders(array('Referer' => $this->referer));

+                                                        $this->requests[$orig] = array('headers'=>null, 'body'=>null, 'httpRequest'=>$httpRequest);

+                                                        $this->requests[$orig]['original_url'] = $orig;

+                                                        $pool->attach($httpRequest);

+                                                }

+                                        }

+                                        // did we get anything into the pool?

+                                        if (count($pool) > 0) {

+                                                $this->debug('Sending request...');

+                                                try {

+                                                        $pool->send();

+                                                } catch (HttpRequestPoolException $e) {

+                                                        // do nothing

+                                                }

+                                                $this->debug('Received responses');

+                                                foreach($subset as $orig => $url) {

+                                                        if (!$isRedirect) $orig = $url;

+                                                        $request = $this->requests[$orig]['httpRequest'];

+                                                        //$this->requests[$orig]['headers'] = $this->headersToString($request->getResponseHeader());

+                                                        // getResponseHeader() doesn't return status line, so, for consistency...

+                                                        $this->requests[$orig]['headers'] = substr($request->getRawResponseMessage(), 0, $request->getResponseInfo('header_size'));

+                                                        // check content type

+                                                        // TODO: use getResponseHeader('content-type') or getResponseInfo()

+                                                        if ($this->headerOnlyType($this->requests[$orig]['headers'])) {

+                                                                $this->requests[$orig]['body'] = '';

+                                                                $_header_only_type = true;

+                                                                $this->debug('Header only type returned');

+                                                        } else {

+                                                                $this->requests[$orig]['body'] = $request->getResponseBody();

+                                                                $_header_only_type = false;

+                                                        }

+                                                        $this->requests[$orig]['effective_url'] = $request->getResponseInfo('effective_url');

+                                                        $this->requests[$orig]['status_code'] = $status_code = $request->getResponseCode();

+                                                        // is redirect?

+                                                        if ((in_array($status_code, array(300, 301, 302, 303, 307)) || $status_code > 307 && $status_code < 400) && $request->getResponseHeader('location')) {

+                                                                $redirectURL = $request->getResponseHeader('location');

+                                                                if (!preg_match('!^https?://!i', $redirectURL)) {

+                                                                        $redirectURL = SimplePie_Misc::absolutize_url($redirectURL, $url);

+                                                                }

+                                                                if ($this->validateURL($redirectURL)) {

+                                                                        $this->debug('Redirect detected. Valid URL: '.$redirectURL);

+                                                                        // store any cookies

+                                                                        $cookies = $request->getResponseHeader('set-cookie');

+                                                                        if ($cookies && !is_array($cookies)) $cookies = array($cookies);

+                                                                        if ($cookies) $this->cookieJar->storeCookies($url, $cookies);

+                                                                        $this->redirectQueue[$orig] = $redirectURL;

+                                                                } else {

+                                                                        $this->debug('Redirect detected. Invalid URL: '.$redirectURL);

+                                                                }

+                                                        } elseif (!$_header_only_type && $request->getMethod() === HttpRequest::METH_HEAD) {

+                                                                // the response content-type did not match our 'header only' types, 

+                                                                // but we'd issues a HEAD request because we assumed it would. So

+                                                                // let's queue a proper GET request for this item...

+                                                                $this->debug('Wrong guess at content-type, queing GET request');

+                                                                $this->requests[$orig]['wrongGuess'] = true;

+                                                                $this->redirectQueue[$orig] = $this->requests[$orig]['effective_url'];

+                                                        } elseif (strpos($this->requests[$orig]['effective_url'], '_escaped_fragment_') === false) {

+                                                                // check for <meta name='fragment' content='!'/>

+                                                                // for AJAX sites, e.g. Blogger with its dynamic views templates.

+                                                                // Based on Google's spec: https://developers.google.com/webmasters/ajax-crawling/docs/specification

+                                                                if (isset($this->requests[$orig]['body'])) {

+                                                                        $redirectURL = $this->getUglyURL($this->requests[$orig]['effective_url'], substr($this->requests[$orig]['body'], 0, 4000));

+                                                                        if ($redirectURL) {

+                                                                                $this->debug('AJAX trigger (meta name="fragment" content="!") found. Queueing '.$redirectURL);

+                                                                                $this->redirectQueue[$orig] = $redirectURL;

+                                                                        }

+                                                                }

+                                                        }

+                                                        //die($url.' -multi- '.$request->getResponseInfo('effective_url'));

+                                                        $pool->detach($request);

+                                                        unset($this->requests[$orig]['httpRequest'], $request);

+                                                        /*

+                                                        if ($this->minimiseMemoryUse) {

+                                                                if ($this->cache($url)) {

+                                                                        unset($this->requests[$url]);

+                                                                }

+                                                        }

+                                                        */

+                                                }

+                                        }

+                                }

+                        } catch (HttpException $e) {

+                                $this->debug($e);

+                                return false;

+                        }

+                }

+                

+                //////////////////////////////////////////////////////////

+                // parallel (curl_multi_*)

+                elseif ($this->method == self::METHOD_CURL_MULTI) {

+                        $this->debug('Starting parallel fetch (curl_multi_*)');

+                        while (count($urls) > 0) {

+                                $this->debug('Processing set of '.min($this->maxParallelRequests, count($urls)));

+                                $subset = array_splice($urls, 0, $this->maxParallelRequests);

+                                $pool = new RollingCurl(array($this, 'handleCurlResponse'));

+                                $pool->window_size = count($subset);            

+                                

+                                foreach ($subset as $orig => $url) {

+                                        if (!$isRedirect) $orig = $url;

+                                        unset($this->redirectQueue[$orig]);

+                                        $this->debug("...$url");

+                                        if (!$isRedirect && isset($this->requests[$url])) {

+                                                $this->debug("......in memory");

+                                        /*

+                                        } elseif ($this->isCached($url)) {

+                                                $this->debug("......is cached");

+                                                if (!$this->minimiseMemoryUse) {

+                                                        $this->requests[$url] = $this->getCached($url);

+                                                }

+                                        */

+                                        } else {

+                                                $this->debug("......adding to pool");

+                                                $req_url = $this->rewriteUrls($url);

+                                                $req_url = ($this->rewriteHashbangFragment) ? $this->rewriteHashbangFragment($req_url) : $req_url;

+                                                $req_url = $this->removeFragment($req_url);

+                                                if (!empty($this->headerOnlyTypes) && !isset($this->requests[$orig]['wrongGuess']) && $this->possibleUnsupportedType($req_url)) {

+                                                        $_meth = 'HEAD';

+                                                } else {

+                                                        $_meth = 'GET';

+                                                        unset($this->requests[$orig]['wrongGuess']);

+                                                }                                               

+                                                $headers = array();

+                                                //$headers[] = 'User-Agent: '.$this->userAgent;

+                                                $headers[] = $this->getUserAgent($req_url);

+                                                // add referer for picky sites

+                                                $headers[] = 'Referer: '.$this->referer;

+                                                // send cookies, if we have any

+                                                if ($cookies = $this->cookieJar->getMatchingCookies($req_url)) {

+                                                        $this->debug("......sending cookies: $cookies");

+                                                        $headers[] = 'Cookie: '.$cookies;

+                                                }

+                                                $httpRequest = new RollingCurlRequest($req_url, $_meth, null, $headers, array(

+                                                        CURLOPT_CONNECTTIMEOUT => $this->requestOptions['timeout'],

+                                                        CURLOPT_TIMEOUT => $this->requestOptions['timeout']

+                                                        ));

+                                                $httpRequest->set_original_url($orig);

+                                                $this->requests[$orig] = array('headers'=>null, 'body'=>null, 'httpRequest'=>$httpRequest);

+                                                $this->requests[$orig]['original_url'] = $orig; // TODO: is this needed anymore?

+                                                $pool->add($httpRequest);

+                                        }

+                                }

+                                // did we get anything into the pool?

+                                if (count($pool) > 0) {

+                                        $this->debug('Sending request...');

+                                        $pool->execute(); // this will call handleCurlResponse() and populate $this->requests[$orig]

+                                        $this->debug('Received responses');

+                                        foreach($subset as $orig => $url) {

+                                                if (!$isRedirect) $orig = $url;

+                                                // $this->requests[$orig]['headers']

+                                                // $this->requests[$orig]['body']

+                                                // $this->requests[$orig]['effective_url']

+                                                // check content type

+                                                if ($this->headerOnlyType($this->requests[$orig]['headers'])) {

+                                                        $this->requests[$orig]['body'] = '';

+                                                        $_header_only_type = true;

+                                                        $this->debug('Header only type returned');

+                                                } else {

+                                                        $_header_only_type = false;

+                                                }

+                                                $status_code = $this->requests[$orig]['status_code'];

+                                                if ((in_array($status_code, array(300, 301, 302, 303, 307)) || $status_code > 307 && $status_code < 400) && isset($this->requests[$orig]['location'])) {

+                                                        $redirectURL = $this->requests[$orig]['location'];

+                                                        if (!preg_match('!^https?://!i', $redirectURL)) {

+                                                                $redirectURL = SimplePie_Misc::absolutize_url($redirectURL, $url);

+                                                        }

+                                                        if ($this->validateURL($redirectURL)) {

+                                                                $this->debug('Redirect detected. Valid URL: '.$redirectURL);

+                                                                // store any cookies

+                                                                $cookies = $this->cookieJar->extractCookies($this->requests[$orig]['headers']);

+                                                                if (!empty($cookies)) $this->cookieJar->storeCookies($url, $cookies);                                                   

+                                                                $this->redirectQueue[$orig] = $redirectURL;

+                                                        } else {

+                                                                $this->debug('Redirect detected. Invalid URL: '.$redirectURL);

+                                                        }

+                                                } elseif (!$_header_only_type && $this->requests[$orig]['method'] == 'HEAD') {

+                                                        // the response content-type did not match our 'header only' types, 

+                                                        // but we'd issues a HEAD request because we assumed it would. So

+                                                        // let's queue a proper GET request for this item...

+                                                        $this->debug('Wrong guess at content-type, queing GET request');

+                                                        $this->requests[$orig]['wrongGuess'] = true;

+                                                        $this->redirectQueue[$orig] = $this->requests[$orig]['effective_url'];

+                                                } elseif (strpos($this->requests[$orig]['effective_url'], '_escaped_fragment_') === false) {

+                                                        // check for <meta name='fragment' content='!'/>

+                                                        // for AJAX sites, e.g. Blogger with its dynamic views templates.

+                                                        // Based on Google's spec: https://developers.google.com/webmasters/ajax-crawling/docs/specification

+                                                        if (isset($this->requests[$orig]['body'])) {

+                                                                $redirectURL = $this->getUglyURL($this->requests[$orig]['effective_url'], substr($this->requests[$orig]['body'], 0, 4000));

+                                                                if ($redirectURL) {

+                                                                        $this->debug('AJAX trigger (meta name="fragment" content="!") found. Queueing '.$redirectURL);

+                                                                        $this->redirectQueue[$orig] = $redirectURL;

+                                                                }

+                                                        }

+                                                }

+                                                // die($url.' -multi- '.$request->getResponseInfo('effective_url'));

+                                                unset($this->requests[$orig]['httpRequest'], $this->requests[$orig]['method']);

+                                        }

+                                }

+                        }

+                }

+

+                //////////////////////////////////////////////////////

+                // sequential (file_get_contents)

+                else {

+                        $this->debug('Starting sequential fetch (file_get_contents)');

+                        $this->debug('Processing set of '.count($urls));

+                        foreach ($urls as $orig => $url) {

+                                if (!$isRedirect) $orig = $url;

+                                unset($this->redirectQueue[$orig]);

+                                $this->debug("...$url");

+                                if (!$isRedirect && isset($this->requests[$url])) {

+                                        $this->debug("......in memory");

+                                /*

+                                } elseif ($this->isCached($url)) {

+                                        $this->debug("......is cached");

+                                        if (!$this->minimiseMemoryUse) {

+                                                $this->requests[$url] = $this->getCached($url);

+                                        }

+                                */

+                                } else {

+                                        $this->debug("Sending request for $url");

+                                        $this->requests[$orig]['original_url'] = $orig;

+                                        $req_url = $this->rewriteUrls($url);

+                                        $req_url = ($this->rewriteHashbangFragment) ? $this->rewriteHashbangFragment($req_url) : $req_url;

+                                        $req_url = $this->removeFragment($req_url);

+                                        // send cookies, if we have any

+                                        $httpContext = $this->httpContext;

+                                        $httpContext['http']['header'] .= $this->getUserAgent($req_url)."\r\n";

+                                        // add referer for picky sites

+                                        $httpContext['http']['header'] .= 'Referer: '.$this->referer."\r\n";

+                                        if ($cookies = $this->cookieJar->getMatchingCookies($req_url)) {

+                                                $this->debug("......sending cookies: $cookies");

+                                                $httpContext['http']['header'] .= 'Cookie: '.$cookies."\r\n";

+                                        }

+                                        if (false !== ($html = @file_get_contents($req_url, false, stream_context_create($httpContext)))) {

+                                                $this->debug('Received response');

+                                                // get status code

+                                                if (!isset($http_response_header[0]) || !preg_match('!^HTTP/\d+\.\d+\s+(\d+)!', trim($http_response_header[0]), $match)) {

+                                                        $this->debug('Error: no status code found');

+                                                        // TODO: handle error - no status code

+                                                } else {

+                                                        $this->requests[$orig]['headers'] = $this->headersToString($http_response_header, false);

+                                                        // check content type

+                                                        if ($this->headerOnlyType($this->requests[$orig]['headers'])) {

+                                                                $this->requests[$orig]['body'] = '';

+                                                        } else {

+                                                                $this->requests[$orig]['body'] = $html;

+                                                        }

+                                                        $this->requests[$orig]['effective_url'] = $req_url;

+                                                        $this->requests[$orig]['status_code'] = $status_code = (int)$match[1];

+                                                        unset($match);

+                                                        // handle redirect

+                                                        if (preg_match('/^Location:(.*?)$/mi', $this->requests[$orig]['headers'], $match)) {

+                                                                $this->requests[$orig]['location'] =  trim($match[1]);

+                                                        }

+                                                        if ((in_array($status_code, array(300, 301, 302, 303, 307)) || $status_code > 307 && $status_code < 400) && isset($this->requests[$orig]['location'])) {

+                                                                $redirectURL = $this->requests[$orig]['location'];

+                                                                if (!preg_match('!^https?://!i', $redirectURL)) {

+                                                                        $redirectURL = SimplePie_Misc::absolutize_url($redirectURL, $url);

+                                                                }

+                                                                if ($this->validateURL($redirectURL)) {

+                                                                        $this->debug('Redirect detected. Valid URL: '.$redirectURL);

+                                                                        // store any cookies

+                                                                        $cookies = $this->cookieJar->extractCookies($this->requests[$orig]['headers']);

+                                                                        if (!empty($cookies)) $this->cookieJar->storeCookies($url, $cookies);

+                                                                        $this->redirectQueue[$orig] = $redirectURL;

+                                                                } else {

+                                                                        $this->debug('Redirect detected. Invalid URL: '.$redirectURL);

+                                                                }

+                                                        } elseif (strpos($this->requests[$orig]['effective_url'], '_escaped_fragment_') === false) {

+                                                                // check for <meta name='fragment' content='!'/>

+                                                                // for AJAX sites, e.g. Blogger with its dynamic views templates.

+                                                                // Based on Google's spec: https://developers.google.com/webmasters/ajax-crawling/docs/specification

+                                                                if (isset($this->requests[$orig]['body'])) {

+                                                                        $redirectURL = $this->getUglyURL($this->requests[$orig]['effective_url'], substr($this->requests[$orig]['body'], 0, 4000));

+                                                                        if ($redirectURL) {

+                                                                                $this->debug('AJAX trigger (meta name="fragment" content="!") found. Queueing '.$redirectURL);

+                                                                                $this->redirectQueue[$orig] = $redirectURL;

+                                                                        }

+                                                                }

+                                                        }

+                                                }

+                                        } else {

+                                                $this->debug('Error retrieving URL');

+                                                //print_r($req_url);

+                                                //print_r($http_response_header);

+                                                //print_r($html);

+                                                

+                                                // TODO: handle error - failed to retrieve URL

+                                        }

+                                }

+                        }

+                }

+        }

+        

+        public function handleCurlResponse($response, $info, $request) {

+                $orig = $request->url_original;

+                $this->requests[$orig]['headers'] = substr($response, 0, $info['header_size']);

+                $this->requests[$orig]['body'] = substr($response, $info['header_size']);

+                $this->requests[$orig]['method'] = $request->method;

+                $this->requests[$orig]['effective_url'] = $info['url'];

+                $this->requests[$orig]['status_code'] = (int)$info['http_code'];

+                if (preg_match('/^Location:(.*?)$/mi', $this->requests[$orig]['headers'], $match)) {

+                        $this->requests[$orig]['location'] =  trim($match[1]);

+                }

+        }

+        

+        protected function headersToString(array $headers, $associative=true) {

+                if (!$associative) {

+                        return implode("\n", $headers);

+                } else {

+                        $str = '';

+                        foreach ($headers as $key => $val) {

+                                if (is_array($val)) {

+                                        foreach ($val as $v) $str .= "$key: $v\n";

+                                } else {

+                                        $str .= "$key: $val\n";

+                                }

+                        }

+                        return rtrim($str);

+                }

+        }

+        

+        public function get($url, $remove=false, $gzdecode=true) {

+                $url = "$url";

+                if (isset($this->requests[$url]) && isset($this->requests[$url]['body'])) {

+                        $this->debug("URL already fetched - in memory ($url, effective: {$this->requests[$url]['effective_url']})");

+                        $response = $this->requests[$url];

+                /*

+                } elseif ($this->isCached($url)) {

+                        $this->debug("URL already fetched - in disk cache ($url)");

+                        $response = $this->getCached($url);

+                        $this->requests[$url] = $response;

+                */

+                } else {

+                        $this->debug("Fetching URL ($url)");

+                        $this->fetchAll(array($url));

+                        if (isset($this->requests[$url]) && isset($this->requests[$url]['body'])) {

+                                $response = $this->requests[$url];

+                        } else {

+                                $this->debug("Request failed");

+                                $response = false;

+                        }

+                }

+                /*

+                if ($this->minimiseMemoryUse && $response) {

+                        $this->cache($url);

+                        unset($this->requests[$url]);

+                }

+                */

+                if ($remove && $response) unset($this->requests[$url]);

+                if ($gzdecode && stripos($response['headers'], 'Content-Encoding: gzip')) {

+                        if ($html = gzdecode($response['body'])) {

+                                $response['body'] = $html;

+                        }

+                }

+                return $response;

+        }

+        

+        public function parallelSupport() {

+                return class_exists('HttpRequestPool') || function_exists('curl_multi_init');

+        }

+        

+        private function headerOnlyType($headers) {

+                if (preg_match('!^Content-Type:\s*(([a-z-]+)/([^;\r\n ]+))!im', $headers, $match)) {

+                        // look for full mime type (e.g. image/jpeg) or just type (e.g. image)

+                        $match[1] = strtolower(trim($match[1]));

+                        $match[2] = strtolower(trim($match[2]));

+                        foreach (array($match[1], $match[2]) as $mime) {

+                                if (in_array($mime, $this->headerOnlyTypes)) return true;

+                        }

+                }

+                return false;

+        }

+        

+        private function possibleUnsupportedType($url) {

+                $path = @parse_url($url, PHP_URL_PATH);

+                if ($path && strpos($path, '.') !== false) {

+                        $ext = strtolower(trim(pathinfo($path, PATHINFO_EXTENSION)));

+                        return in_array($ext, $this->headerOnlyClues);

+                }

+                return false;

+        }

+}

+

+// gzdecode from http://www.php.net/manual/en/function.gzdecode.php#82930

+if (!function_exists('gzdecode')) {

+        function gzdecode($data,&$filename='',&$error='',$maxlength=null) 

+        {

+                $len = strlen($data);

+                if ($len < 18 || strcmp(substr($data,0,2),"\x1f\x8b")) {

+                        $error = "Not in GZIP format.";

+                        return null;  // Not GZIP format (See RFC 1952)

+                }

+                $method = ord(substr($data,2,1));  // Compression method

+                $flags  = ord(substr($data,3,1));  // Flags

+                if ($flags & 31 != $flags) {

+                        $error = "Reserved bits not allowed.";

+                        return null;

+                }

+                // NOTE: $mtime may be negative (PHP integer limitations)

+                $mtime = unpack("V", substr($data,4,4));

+                $mtime = $mtime[1];

+                $xfl   = substr($data,8,1);

+                $os    = substr($data,8,1);

+                $headerlen = 10;

+                $extralen  = 0;

+                $extra     = "";

+                if ($flags & 4) {

+                        // 2-byte length prefixed EXTRA data in header

+                        if ($len - $headerlen - 2 < 8) {

+                                return false;  // invalid

+                        }

+                        $extralen = unpack("v",substr($data,8,2));

+                        $extralen = $extralen[1];

+                        if ($len - $headerlen - 2 - $extralen < 8) {

+                                return false;  // invalid

+                        }

+                        $extra = substr($data,10,$extralen);

+                        $headerlen += 2 + $extralen;

+                }

+                $filenamelen = 0;

+                $filename = "";

+                if ($flags & 8) {

+                        // C-style string

+                        if ($len - $headerlen - 1 < 8) {

+                                return false; // invalid

+                        }

+                        $filenamelen = strpos(substr($data,$headerlen),chr(0));

+                        if ($filenamelen === false || $len - $headerlen - $filenamelen - 1 < 8) {

+                                return false; // invalid

+                        }

+                        $filename = substr($data,$headerlen,$filenamelen);

+                        $headerlen += $filenamelen + 1;

+                }

+                $commentlen = 0;

+                $comment = "";

+                if ($flags & 16) {

+                        // C-style string COMMENT data in header

+                        if ($len - $headerlen - 1 < 8) {

+                                return false;    // invalid

+                        }

+                        $commentlen = strpos(substr($data,$headerlen),chr(0));

+                        if ($commentlen === false || $len - $headerlen - $commentlen - 1 < 8) {

+                                return false;    // Invalid header format

+                        }

+                        $comment = substr($data,$headerlen,$commentlen);

+                        $headerlen += $commentlen + 1;

+                }

+                $headercrc = "";

+                if ($flags & 2) {

+                        // 2-bytes (lowest order) of CRC32 on header present

+                        if ($len - $headerlen - 2 < 8) {

+                                return false;    // invalid

+                        }

+                        $calccrc = crc32(substr($data,0,$headerlen)) & 0xffff;

+                        $headercrc = unpack("v", substr($data,$headerlen,2));

+                        $headercrc = $headercrc[1];

+                        if ($headercrc != $calccrc) {

+                                $error = "Header checksum failed.";

+                                return false;    // Bad header CRC

+                        }

+                        $headerlen += 2;

+                }

+                // GZIP FOOTER

+                $datacrc = unpack("V",substr($data,-8,4));

+                $datacrc = sprintf('%u',$datacrc[1] & 0xFFFFFFFF);

+                $isize = unpack("V",substr($data,-4));

+                $isize = $isize[1];

+                // decompression:

+                $bodylen = $len-$headerlen-8;

+                if ($bodylen < 1) {

+                        // IMPLEMENTATION BUG!

+                        return null;

+                }

+                $body = substr($data,$headerlen,$bodylen);

+                $data = "";

+                if ($bodylen > 0) {

+                        switch ($method) {

+                        case 8:

+                                // Currently the only supported compression method:

+                                $data = gzinflate($body,$maxlength);

+                                break;

+                        default:

+                                $error = "Unknown compression method.";

+                                return false;

+                        }

+                }  // zero-byte body content is allowed

+                // Verifiy CRC32

+                $crc   = sprintf("%u",crc32($data));

+                $crcOK = $crc == $datacrc;

+                $lenOK = $isize == strlen($data);

+                if (!$lenOK || !$crcOK) {

+                        $error = ( $lenOK ? '' : 'Length check FAILED. ') . ( $crcOK ? '' : 'Checksum FAILED.');

+                        return false;

+                }

+                return $data;

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/humble-http-agent/RollingCurl.php b/inc/3rdparty/libraries/humble-http-agent/RollingCurl.php
new file mode 100644
index 00000000..d24dc690
--- /dev/null
+++ b/inc/3rdparty/libraries/humble-http-agent/RollingCurl.php
@@ -0,0 +1,402 @@
+<?php

+/*

+Authored by Josh Fraser (www.joshfraser.com)

+Released under Apache License 2.0

+

+Maintained by Alexander Makarov, http://rmcreative.ru/

+

+Modified by Keyvan Minoukadeh for the Five Filters project: http://fivefilters.org

+*/

+

+/**

+ * Class that represent a single curl request

+ */

+class RollingCurlRequest {

+    public $url = false;

+        public $url_original = false; // used for tracking redirects

+    public $method = 'GET';

+    public $post_data = null;

+    public $headers = null;

+    public $options = null;

+

+    /**

+     * @param string $url

+     * @param string $method

+     * @param  $post_data

+     * @param  $headers

+     * @param  $options

+     * @return void

+     */

+    function __construct($url, $method = "GET", $post_data = null, $headers = null, $options = null) {

+        $this->url = $url;

+                $this->url_original = $url;

+        $this->method = $method;

+        $this->post_data = $post_data;

+        $this->headers = $headers;

+        $this->options = $options;

+    }

+        

+    /**

+     * @param string $url

+     * @return void

+     */

+    public function set_original_url($url) {

+                $this->url_original = $url;

+        }

+    /**

+     * @return void

+     */

+    public function __destruct() {

+        unset($this->url, $this->url_original, $this->method, $this->post_data, $this->headers, $this->options);

+    }

+}

+

+/**

+ * RollingCurl custom exception

+ */

+class RollingCurlException extends Exception {

+}

+

+/**

+ * Class that holds a rolling queue of curl requests.

+ *

+ * @throws RollingCurlException

+ */

+class RollingCurl implements Countable {

+    /**

+     * @var int

+     *

+     * Window size is the max number of simultaneous connections allowed.

+     *

+     * REMEMBER TO RESPECT THE SERVERS:

+     * Sending too many requests at one time can easily be perceived

+     * as a DOS attack. Increase this window_size if you are making requests

+     * to multiple servers or have permission from the receving server admins.

+     */

+    private $window_size = 5;

+

+    /**

+     * @var float

+     *

+     * Timeout is the timeout used for curl_multi_select.

+     */

+    private $timeout = 10;

+

+    /**

+     * @var string|array

+     *

+     * Callback function to be applied to each result.

+     */

+    private $callback;

+

+    /**

+     * @var array

+     *

+     * Set your base options that you want to be used with EVERY request.

+     */

+    protected $options = array(

+        CURLOPT_SSL_VERIFYPEER => 0,

+        CURLOPT_RETURNTRANSFER => 1,

+        CURLOPT_CONNECTTIMEOUT => 30,

+        CURLOPT_TIMEOUT => 30

+    );

+

+    /**

+     * @var array

+     */

+    private $headers = array();

+

+    /**

+     * @var Request[]

+     *

+     * The request queue

+     */

+    private $requests = array();

+

+    /**

+     * @var RequestMap[]

+     *

+     * Maps handles to request indexes

+     */

+    private $requestMap = array();

+

+    /**

+     * @param  $callback

+     * Callback function to be applied to each result.

+     *

+     * Can be specified as 'my_callback_function'

+     * or array($object, 'my_callback_method').

+     *

+     * Function should take three parameters: $response, $info, $request.

+     * $response is response body, $info is additional curl info.

+     * $request is the original request

+     *

+     * @return void

+     */

+    function __construct($callback = null) {

+        $this->callback = $callback;

+    }

+

+    /**

+     * @param string $name

+     * @return mixed

+     */

+    public function __get($name) {

+        return (isset($this->{$name})) ? $this->{$name} : null;

+    }

+

+    /**

+     * @param string $name

+     * @param mixed $value

+     * @return bool

+     */

+    public function __set($name, $value) {

+        // append the base options & headers

+        if ($name == "options" || $name == "headers") {

+            $this->{$name} = $value + $this->{$name};

+        } else {

+            $this->{$name} = $value;

+        }

+        return true;

+    }

+

+    /**

+     * Count number of requests added (Countable interface)

+     *

+     * @return int

+     */

+    public function count() {

+        return count($this->requests);

+    }   

+        

+    /**

+     * Add a request to the request queue

+     *

+     * @param Request $request

+     * @return bool

+     */

+    public function add($request) {

+        $this->requests[] = $request;

+        return true;

+    }

+

+    /**

+     * Create new Request and add it to the request queue

+     *

+     * @param string $url

+     * @param string $method

+     * @param  $post_data

+     * @param  $headers

+     * @param  $options

+     * @return bool

+     */

+    public function request($url, $method = "GET", $post_data = null, $headers = null, $options = null) {

+        $this->requests[] = new RollingCurlRequest($url, $method, $post_data, $headers, $options);

+        return true;

+    }

+

+    /**

+     * Perform GET request

+     *

+     * @param string $url

+     * @param  $headers

+     * @param  $options

+     * @return bool

+     */

+    public function get($url, $headers = null, $options = null) {

+        return $this->request($url, "GET", null, $headers, $options);

+    }

+

+    /**

+     * Perform POST request

+     *

+     * @param string $url

+     * @param  $post_data

+     * @param  $headers

+     * @param  $options

+     * @return bool

+     */

+    public function post($url, $post_data = null, $headers = null, $options = null) {

+        return $this->request($url, "POST", $post_data, $headers, $options);

+    }

+

+    /**

+     * Execute processing

+     *

+     * @param int $window_size Max number of simultaneous connections

+     * @return string|bool

+     */

+    public function execute($window_size = null) {

+        // rolling curl window must always be greater than 1

+        if (sizeof($this->requests) == 1) {

+            return $this->single_curl();

+        } else {

+            // start the rolling curl. window_size is the max number of simultaneous connections

+            return $this->rolling_curl($window_size);

+        }

+    }

+

+    /**

+     * Performs a single curl request

+     *

+     * @access private

+     * @return string

+     */

+    private function single_curl() {

+        $ch = curl_init();

+        $request = array_shift($this->requests);

+        $options = $this->get_options($request);

+        curl_setopt_array($ch, $options);

+        $output = curl_exec($ch);

+        $info = curl_getinfo($ch);

+

+        // it's not neccesary to set a callback for one-off requests

+        if ($this->callback) {

+            $callback = $this->callback;

+            if (is_callable($this->callback)) {

+                call_user_func($callback, $output, $info, $request);

+            }

+        }

+        else

+            return $output;

+        return true;

+    }

+

+    /**

+     * Performs multiple curl requests

+     *

+     * @access private

+     * @throws RollingCurlException

+     * @param int $window_size Max number of simultaneous connections

+     * @return bool

+     */

+    private function rolling_curl($window_size = null) {

+        if ($window_size)

+            $this->window_size = $window_size;

+

+        // make sure the rolling window isn't greater than the # of urls

+        if (sizeof($this->requests) < $this->window_size)

+            $this->window_size = sizeof($this->requests);

+

+        if ($this->window_size < 2) {

+            throw new RollingCurlException("Window size must be greater than 1");

+        }

+

+        $master = curl_multi_init();

+

+        // start the first batch of requests

+        for ($i = 0; $i < $this->window_size; $i++) {

+            $ch = curl_init();

+

+            $options = $this->get_options($this->requests[$i]);

+

+            curl_setopt_array($ch, $options);

+            curl_multi_add_handle($master, $ch);

+

+            // Add to our request Maps

+            $key = (string) $ch;

+            $this->requestMap[$key] = $i;

+        }

+

+        do {

+            while (($execrun = curl_multi_exec($master, $running)) == CURLM_CALL_MULTI_PERFORM) ;

+            if ($execrun != CURLM_OK)

+                break;

+            // a request was just completed -- find out which one

+            while ($done = curl_multi_info_read($master)) {

+

+                // get the info and content returned on the request

+                $info = curl_getinfo($done['handle']);

+                $output = curl_multi_getcontent($done['handle']);

+

+                // send the return values to the callback function.

+                $callback = $this->callback;

+                if (is_callable($callback)) {

+                    $key = (string) $done['handle'];

+                    $request = $this->requests[$this->requestMap[$key]];

+                    unset($this->requestMap[$key]);

+                    call_user_func($callback, $output, $info, $request);

+                }

+

+                // start a new request (it's important to do this before removing the old one)

+                if ($i < sizeof($this->requests) && isset($this->requests[$i]) && $i < count($this->requests)) {

+                    $ch = curl_init();

+                    $options = $this->get_options($this->requests[$i]);

+                    curl_setopt_array($ch, $options);

+                    curl_multi_add_handle($master, $ch);

+

+                    // Add to our request Maps

+                    $key = (string) $ch;

+                    $this->requestMap[$key] = $i;

+                    $i++;

+                }

+

+                // remove the curl handle that just completed

+                curl_multi_remove_handle($master, $done['handle']);

+

+            }

+

+            // Block for data in / output; error handling is done by curl_multi_exec

+            //if ($running) curl_multi_select($master, $this->timeout);

+                        // removing timeout as it causes problems on Windows with PHP 5.3.5 and Curl 7.20.0

+                        if ($running) curl_multi_select($master);

+

+        } while ($running);

+        curl_multi_close($master);

+        return true;

+    }

+

+

+    /**

+     * Helper function to set up a new request by setting the appropriate options

+     *

+     * @access private

+     * @param Request $request

+     * @return array

+     */

+    private function get_options($request) {

+        // options for this entire curl object

+        $options = $this->__get('options');

+                // We're managing reirects in PHP - allows us to intervene and rewrite/block URLs

+                // before the next request goes out.

+                $options[CURLOPT_FOLLOWLOCATION] = 0;

+        $options[CURLOPT_MAXREDIRS] = 0;

+        //if (ini_get('safe_mode') == 'Off' || !ini_get('safe_mode')) {

+        //    $options[CURLOPT_FOLLOWLOCATION] = 1;

+        //    $options[CURLOPT_MAXREDIRS] = 5;

+        //}

+        $headers = $this->__get('headers');

+                // append custom headers for this specific request

+                if ($request->headers) {

+                        $headers = $headers + $request->headers;

+                }

+

+        // append custom options for this specific request

+        if ($request->options) {

+            $options = $request->options + $options;

+        }

+

+        // set the request URL

+        $options[CURLOPT_URL] = $request->url;

+

+        if ($headers) {

+            $options[CURLOPT_HTTPHEADER] = $headers;

+        }

+                // return response headers

+                $options[CURLOPT_HEADER] = 1;

+                

+                // send HEAD request?

+                if ($request->method == 'HEAD') {

+                        $options[CURLOPT_NOBODY] = 1;

+                }

+

+        return $options;

+    }

+

+    /**

+     * @return void

+     */

+    public function __destruct() {

+        unset($this->window_size, $this->callback, $this->options, $this->headers, $this->requests);

+    }

+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/humble-http-agent/SimplePie_HumbleHttpAgent.php b/inc/3rdparty/libraries/humble-http-agent/SimplePie_HumbleHttpAgent.php
new file mode 100644
index 00000000..ecd46d5f
--- /dev/null
+++ b/inc/3rdparty/libraries/humble-http-agent/SimplePie_HumbleHttpAgent.php
@@ -0,0 +1,79 @@
+<?php

+/**

+ * Humble HTTP Agent extension for SimplePie_File

+ * 

+ * This class is designed to extend and override SimplePie_File

+ * in order to prevent duplicate HTTP requests being sent out.

+ * The idea is to initialise an instance of Humble HTTP Agent

+ * and attach it, to a static class variable, of this class.

+ * SimplePie will then automatically initialise this class

+ * 

+ * @date 2011-02-28

+ */

+

+class SimplePie_HumbleHttpAgent extends SimplePie_File

+{

+        protected static $agent;

+        var $url;

+        var $useragent;

+        var $success = true;

+        var $headers = array();

+        var $body;

+        var $status_code;

+        var $redirects = 0;

+        var $error;

+        var $method = SIMPLEPIE_FILE_SOURCE_NONE;

+

+        public static function set_agent(HumbleHttpAgent $agent) {

+                self::$agent = $agent;

+        }

+        

+        public function __construct($url, $timeout = 10, $redirects = 5, $headers = null, $useragent = null, $force_fsockopen = false) {

+                if (class_exists('idna_convert'))

+                {

+                        $idn = new idna_convert();

+                        $parsed = SimplePie_Misc::parse_url($url);

+                        $url = SimplePie_Misc::compress_parse_url($parsed['scheme'], $idn->encode($parsed['authority']), $parsed['path'], $parsed['query'], $parsed['fragment']);

+                }

+                $this->url = $url;

+                $this->useragent = $useragent;

+                if (preg_match('/^http(s)?:\/\//i', $url))

+                {

+                        if (!is_array($headers))

+                        {

+                                $headers = array();

+                        }

+                        $this->method = SIMPLEPIE_FILE_SOURCE_REMOTE | SIMPLEPIE_FILE_SOURCE_CURL;

+                        $headers2 = array();

+                        foreach ($headers as $key => $value) {

+                                $headers2[] = "$key: $value";

+                        }

+                        //TODO: allow for HTTP headers

+                        // curl_setopt($fp, CURLOPT_HTTPHEADER, $headers2);

+

+                        $response = self::$agent->get($url);

+                        

+                        if ($response === false || !isset($response['status_code'])) {

+                                $this->error = 'failed to fetch URL';

+                                $this->success = false;

+                        } else {

+                                // The extra lines at the end are there to satisfy SimplePie's HTTP parser.

+                                // The class expects a full HTTP message, whereas we're giving it only

+                                // headers - the new lines indicate the start of the body.

+                                $parser = new SimplePie_HTTP_Parser($response['headers']."\r\n\r\n");

+                                if ($parser->parse()) {

+                                        $this->headers = $parser->headers;

+                                        //$this->body = $parser->body;

+                                        $this->body = $response['body'];

+                                        $this->status_code = $parser->status_code;

+                                }

+                        }

+                }

+                else

+                {

+                        $this->error = 'invalid URL';

+                        $this->success = false;

+                }

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/language-detect/LanguageDetect.php b/inc/3rdparty/libraries/language-detect/LanguageDetect.php
new file mode 100644
index 00000000..09b11546
--- /dev/null
+++ b/inc/3rdparty/libraries/language-detect/LanguageDetect.php
@@ -0,0 +1,1635 @@
+<?php
+
+/**
+ * Detects the language of a given piece of text.
+ *
+ * Attempts to detect the language of a sample of text by correlating ranked
+ * 3-gram frequencies to a table of 3-gram frequencies of known languages.
+ *
+ * Implements a version of a technique originally proposed by Cavnar & Trenkle 
+ * (1994): "N-Gram-Based Text Categorization" 
+ *
+ * PHP versions 4 and 5
+ *
+ * @category   Text
+ * @package    Text_LanguageDetect
+ * @author     Nicholas Pisarro <infinityminusnine+pear@gmail.com>
+ * @copyright  2005-2006 Nicholas Pisarro
+ * @license    http://www.debian.org/misc/bsd.license BSD
+ * @version    CVS: $Id: LanguageDetect.php,v 1.20 2008/07/01 02:09:15 taak Exp $
+ * @link       http://pear.php.net/package/Text_LanguageDetect/
+ * @link       http://langdetect.blogspot.com/
+ */
+
+//require_once 'PEAR.php';
+require_once 'Parser.php';
+
+/**
+ * Language detection class
+ *
+ * Requires the langauge model database (lang.dat) that should have
+ * accompanied this class definition in order to be instantiated.
+ *
+ * Example usage:
+ *
+ * <code>
+ * require_once 'Text/LanguageDetect.php';
+ *
+ * $l = new Text_LanguageDetect;
+ *
+ * $stdin = fopen('php://stdin', 'r');
+ *
+ * echo "Supported languages:\n";
+ *
+ * $langs = $l->getLanguages();
+ * if (PEAR::isError($langs)) {
+ *     die($langs->getMessage());
+ * }
+ *
+ * sort($langs);
+ * echo join(', ', $langs);
+ *
+ * while ($line = fgets($stdin)) {
+ *     print_r($l->detect($line, 4));
+ * }
+ * </code>
+ *
+ * @category   Text
+ * @package    Text_LanguageDetect
+ * @author     Nicholas Pisarro <infinityminusnine+pear@gmail.com>
+ * @copyright  2005 Nicholas Pisarro
+ * @license    http://www.debian.org/misc/bsd.license BSD
+ * @version    Release: @package_version@
+ * @todo       allow users to generate their own language models
+ */
+ 
+class Text_LanguageDetect
+{
+    /** 
+     * The filename that stores the trigram data for the detector
+     *
+     * If this value starts with a slash (/) or a dot (.) the value of 
+     * $this->_data_dir will be ignored
+     * 
+     * @var      string
+     * @access   private
+     */
+    var $_db_filename = './lang.dat';
+
+    /**
+     * The filename that stores the unicode block definitions
+     *
+     * If this value starts with a slash (/) or a dot (.) the value of 
+     * $this->_data_dir will be ignored
+     * 
+     * @var string
+     * @access private
+     */
+    var $_unicode_db_filename = './unicode_blocks.dat';
+
+    /**
+     * The data directory
+     *
+     * Should be set by PEAR installer
+     *
+     * @var      string
+     * @access   private
+     */
+    var $_data_dir = '@data_dir@';
+
+    /**
+     * The trigram data for comparison
+     * 
+     * Will be loaded on start from $this->_db_filename
+     *
+     * May be set to a PEAR_Error object if there is an error during its 
+     * initialization
+     *
+     * @var      array
+     * @access   private
+     */
+    var $_lang_db = array();
+
+    /**
+     * stores the map of the trigram data to unicode characters
+     *
+     * @access private
+     * @var array
+     */
+    var $_unicode_map;
+
+    /**
+     * The size of the trigram data arrays
+     * 
+     * @var      int
+     * @access   private
+     */
+    var $_threshold = 300;
+
+    /**
+     * the maximum possible score.
+     *
+     * needed for score normalization. Different depending on the
+     * perl compatibility setting
+     *
+     * @access  private
+     * @var     int
+     * @see     setPerlCompatible()
+     */
+    var $_max_score = 0;
+
+    /**
+     * Whether or not to simulate perl's Language::Guess exactly
+     * 
+     * @access  private
+     * @var     bool
+     * @see     setPerlCompatible()
+     */
+    var $_perl_compatible = false;
+
+    /**
+     * Whether to use the unicode block detection to speed up processing
+     *
+     * @access private
+     * @var bool
+     */
+    var $_use_unicode_narrowing = true;
+
+    /**
+     * stores the result of the clustering operation
+     *
+     * @access  private
+     * @var     array
+     * @see     clusterLanguages()
+     */
+    var $_clusters;
+
+    /**
+     * Constructor
+     *
+     * Will attempt to load the language database. If it fails, you will get
+     * a PEAR_Error object returned when you try to use detect()
+     *
+     */
+    function Text_LanguageDetect($db=null, $unicode_db=null)
+    {
+                if (isset($db)) $this->_db_filename = $db;
+                if (isset($unicode_db)) $this->_unicode_db_filename = $unicode_db;
+                
+        $data = $this->_readdb($this->_db_filename);
+        $this->_lang_db = $data['trigram'];
+
+        if (isset($data['trigram-unicodemap'])) {
+            $this->_unicode_map = $data['trigram-unicodemap'];
+        }
+
+        // Not yet implemented:
+        if (isset($data['trigram-clusters'])) {
+            $this->_clusters = $data['trigram-clusters'];
+        }               
+    }
+
+    /**
+     * Returns the path to the location of the database
+     *
+     * @access    private
+     * @return    string    expected path to the language model database
+     */
+    function _get_data_loc($fname)
+    {
+        return $fname;
+    }
+
+    /**
+     * Loads the language trigram database from filename
+     *
+     * Trigram datbase should be a serialize()'d array
+     * 
+     * @access    private
+     * @param     string      $fname   the filename where the data is stored
+     * @return    array                the language model data
+     * @throws    PEAR_Error
+     */
+    function _readdb($fname)
+    {
+        // finds the correct data dir
+        $fname = $this->_get_data_loc($fname);
+
+        // input check
+        if (!file_exists($fname)) {
+            throw new Exception('Language database does not exist.');
+        } elseif (!is_readable($fname)) {
+            throw new Exception('Language database is not readable.');
+        }
+
+        if (function_exists('file_get_contents')) {
+            return unserialize(file_get_contents($fname));
+        } else {
+            // if you don't have file_get_contents(), 
+            // then this is the next fastest way
+            ob_start();
+            readfile($fname);
+            $contents = ob_get_contents();
+            ob_end_clean();
+            return unserialize($contents);
+        }
+    }
+
+
+    /**
+     * Checks if this object is ready to detect languages
+     * 
+     * @access   private
+     * @param    mixed   &$err  error object to be returned by reference, if any
+     * @return   bool           true if no errors
+     */
+    function _setup_ok(&$err)
+    {
+        if (!is_array($this->_lang_db)) {
+            if (ini_get('magic_quotes_runtime')) {
+                throw new Exception('Error loading database. Try turning magic_quotes_runtime off.');
+            } else {
+                throw new Exception('Language database is not an array.');
+            }
+            return false;
+
+        } elseif (empty($this->_lang_db)) {
+            throw new Exception('Language database has no elements.');
+            return false;
+
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * Omits languages
+     *
+     * Pass this function the name of or an array of names of 
+     * languages that you don't want considered
+     *
+     * If you're only expecting a limited set of languages, this can greatly 
+     * speed up processing
+     *
+     * @access   public
+     * @param    mixed  $omit_list      language name or array of names to omit
+     * @param    bool   $include_only   if true will include (rather than 
+     *                                  exclude) only those in the list
+     * @return   int                    number of languages successfully deleted
+     * @throws   PEAR_Error
+     */
+    function omitLanguages($omit_list, $include_only = false)
+    {
+
+        // setup check
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        }
+
+        $deleted = 0;
+
+        // deleting the given languages
+        if (!$include_only) {
+            if (!is_array($omit_list)) {
+                $omit_list = strtolower($omit_list); // case desensitize
+                if (isset($this->_lang_db[$omit_list])) {
+                    unset($this->_lang_db[$omit_list]);
+                    $deleted++;
+                }
+            } else {
+                foreach ($omit_list as $omit_lang) {
+                    if (isset($this->_lang_db[$omit_lang])) {
+                        unset($this->_lang_db[$omit_lang]);
+                        $deleted++;
+                    } 
+                }
+            }
+
+        // deleting all except the given languages
+        } else {
+            if (!is_array($omit_list)) {
+                $omit_list = array($omit_list);
+            }
+
+            // case desensitize
+            foreach ($omit_list as $key => $omit_lang) {
+                $omit_list[$key] = strtolower($omit_lang);
+            }
+
+            foreach (array_keys($this->_lang_db) as $lang) {
+                if (!in_array($lang, $omit_list)) {
+                    unset($this->_lang_db[$lang]);
+                    $deleted++;
+                }
+            }
+        }
+
+        // reset the cluster cache if the number of languages changes
+        // this will then have to be recalculated
+        if (isset($this->_clusters) && $deleted > 0) {
+            unset($this->_clusters);
+        }
+
+        return $deleted;
+    }
+
+
+    /**
+     * Returns the number of languages that this object can detect
+     *
+     * @access public
+     * @return int            the number of languages
+     * @throws PEAR_Error
+     */
+    function getLanguageCount()
+    {
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        } else {
+            return count($this->_lang_db);
+        }
+    }
+
+    /**
+     * Returns true if a given language exists
+     *
+     * If passed an array of names, will return true only if all exist
+     *
+     * @access    public
+     * @param     mixed       $lang    language name or array of language names
+     * @return    bool                 true if language model exists
+     * @throws    PEAR_Error
+     */
+    function languageExists($lang)
+    {
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        } else {
+            // string
+            if (is_string($lang)) {
+                return isset($this->_lang_db[strtolower($lang)]);
+
+            // array
+            } elseif (is_array($lang)) {
+                foreach ($lang as $test_lang) {
+                    if (!isset($this->_lang_db[strtolower($test_lang)])) {
+                        return false;
+                    } 
+                }
+                return true;
+
+            // other (error)
+            } else {
+                throw new Exception('Unknown type passed to languageExists()');
+            }
+        }
+    }
+
+    /**
+     * Returns the list of detectable languages
+     *
+     * @access public
+     * @return array        the names of the languages known to this object
+     * @throws PEAR_Error
+     */
+    function getLanguages()
+    {
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        } else {
+            return array_keys($this->_lang_db);
+        }
+    }
+
+    /**
+     * Make this object behave like Language::Guess
+     * 
+     * @access    public
+     * @param     bool     $setting     false to turn off perl compatibility
+     */
+    function setPerlCompatible($setting = true)
+    {
+        if (is_bool($setting)) { // input check
+            $this->_perl_compatible = $setting;
+
+            if ($setting == true) {
+                $this->_max_score = $this->_threshold;
+            } else {
+                $this->_max_score = 0;
+            }
+        }
+
+    }
+
+    /**
+     * Whether to use unicode block ranges in detection
+     *
+     * Should speed up most detections if turned on (detault is on). In some
+     * circumstances it may be slower, such as for large text samples (> 10K)
+     * in languages that use latin scripts. In other cases it should speed up
+     * detection noticeably.
+     *
+     * @access  public
+     * @param   bool    $setting    false to turn off
+     */
+    function useUnicodeBlocks($setting = true)
+    {
+        if (is_bool($setting)) {
+            $this->_use_unicode_narrowing = $setting;
+        }
+    }
+
+    /**
+     * Converts a piece of text into trigrams
+     *
+     * Superceded by the Text_LanguageDetect_Parser class 
+     *
+     * @access    private
+     * @param     string    $text    text to convert
+     * @return    array              array of trigram frequencies
+     */
+    function _trigram($text)
+    {
+        $s = new Text_LanguageDetect_Parser($text, $this->_db_filename, $this->_unicode_db_filename);
+        $s->prepareTrigram();
+        $s->prepareUnicode(false);
+        $s->setPadStart(!$this->_perl_compatible);
+        $s->analyze();
+        return $s->getTrigramFreqs();
+    }
+
+    /**
+     * Converts a set of trigrams from frequencies to ranks
+     *
+     * Thresholds (cuts off) the list at $this->_threshold
+     *
+     * @access    protected
+     * @param     array     $arr     array of trgram 
+     * @return    array              ranks of trigrams
+     */
+    function _arr_rank(&$arr)
+    {
+
+        // sorts alphabetically first as a standard way of breaking rank ties
+        $this->_bub_sort($arr);
+
+        // below might also work, but seemed to introduce errors in testing
+        //ksort($arr);
+        //asort($arr);
+
+        $rank = array();
+
+        $i = 0;
+        foreach ($arr as $key => $value) {
+            $rank[$key] = $i++;
+
+            // cut off at a standard threshold
+            if ($i >= $this->_threshold) {
+                break;
+            }
+        }
+
+        return $rank;
+    }
+
+    /**
+     * Sorts an array by value breaking ties alphabetically
+     * 
+     * @access   private
+     * @param    array     &$arr     the array to sort
+     */
+    function _bub_sort(&$arr)
+    {
+        // should do the same as this perl statement:
+        // sort { $trigrams{$b} == $trigrams{$a} ?  $a cmp $b : $trigrams{$b} <=> $trigrams{$a} }
+
+        // needs to sort by both key and value at once
+        // using the key to break ties for the value
+
+        // converts array into an array of arrays of each key and value
+        // may be a better way of doing this
+        $combined = array();
+
+        foreach ($arr as $key => $value) {
+            $combined[] = array($key, $value);
+        }
+
+        usort($combined, array($this, '_sort_func'));
+
+        $replacement = array();
+        foreach ($combined as $key => $value) {
+            list($new_key, $new_value) = $value;
+            $replacement[$new_key] = $new_value;
+        }
+
+        $arr = $replacement;
+    }
+
+    /**
+     * Sort function used by bubble sort
+     *
+     * Callback function for usort(). 
+     *
+     * @access   private
+     * @param    array        first param passed by usort()
+     * @param    array        second param passed by usort()
+     * @return   int          1 if $a is greater, -1 if not
+     * @see      _bub_sort()
+     */
+    function _sort_func($a, $b)
+    {
+        // each is actually a key/value pair, so that it can compare using both
+        list($a_key, $a_value) = $a;
+        list($b_key, $b_value) = $b;
+
+        // if the values are the same, break ties using the key
+        if ($a_value == $b_value) {
+            return strcmp($a_key, $b_key);
+
+        // if not, just sort normally
+        } else {
+            if ($a_value > $b_value) {
+                return -1;
+            } else {
+                return 1;
+            }
+        }
+
+        // 0 should not be possible because keys must be unique
+    }
+
+    /**
+     * Calculates a linear rank-order distance statistic between two sets of 
+     * ranked trigrams
+     *
+     * Sums the differences in rank for each trigram. If the trigram does not 
+     * appear in both, consider it a difference of $this->_threshold.
+     *
+     * This distance measure was proposed by Cavnar & Trenkle (1994). Despite
+     * its simplicity it has been shown to be highly accurate for language
+     * identification tasks.
+     *
+     * @access  private
+     * @param   array    $arr1  the reference set of trigram ranks
+     * @param   array    $arr2  the target set of trigram ranks
+     * @return  int             the sum of the differences between the ranks of
+     *                          the two trigram sets
+     */
+    function _distance(&$arr1, &$arr2)
+    {
+        $sumdist = 0;
+
+        foreach ($arr2 as $key => $value) {
+            if (isset($arr1[$key])) {
+                $distance = abs($value - $arr1[$key]);
+            } else {
+                // $this->_threshold sets the maximum possible distance value
+                // for any one pair of trigrams
+                $distance = $this->_threshold;
+            }
+            $sumdist += $distance;
+        }
+
+        return $sumdist;
+
+        // todo: there are other distance statistics to try, e.g. relative
+        //       entropy, but they're probably more costly to compute
+    }
+
+    /**
+     * Normalizes the score returned by _distance()
+     * 
+     * Different if perl compatible or not
+     *
+     * @access    private
+     * @param     int    $score          the score from _distance()
+     * @param     int    $base_count     the number of trigrams being considered
+     * @return    float                  the normalized score
+     * @see       _distance()
+     */
+    function _normalize_score($score, $base_count = null)
+    {
+        if ($base_count === null) {
+            $base_count = $this->_threshold;
+        }
+
+        if (!$this->_perl_compatible) {
+            return 1 - ($score / $base_count / $this->_threshold);
+        } else {
+            return floor($score / $base_count);
+        }
+    }
+
+
+    /**
+     * Detects the closeness of a sample of text to the known languages
+     *
+     * Calculates the statistical difference between the text and
+     * the trigrams for each language, normalizes the score then
+     * returns results for all languages in sorted order
+     *
+     * If perl compatible, the score is 300-0, 0 being most similar.
+     * Otherwise, it's 0-1 with 1 being most similar.
+     * 
+     * The $sample text should be at least a few sentences in length;
+     * should be ascii-7 or utf8 encoded, if another and the mbstring extension
+     * is present it will try to detect and convert. However, experience has
+     * shown that mb_detect_encoding() *does not work very well* with at least 
+     * some types of encoding.
+     *
+     * @access  public
+     * @param   string  $sample a sample of text to compare.
+     * @param   int     $limit  if specified, return an array of the most likely
+     *                           $limit languages and their scores.
+     * @return  mixed       sorted array of language scores, blank array if no 
+     *                      useable text was found, or PEAR_Error if error 
+     *                      with the object setup
+     * @see     _distance()
+     * @throws  PEAR_Error
+     */
+    function detect($sample, $limit = 0)
+    {
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        }
+
+        // input check
+        if (!Text_LanguageDetect_Parser::validateString($sample)) {
+            return array();
+        }
+
+        // check char encoding
+        // (only if mbstring extension is compiled and PHP > 4.0.6)
+        if (function_exists('mb_detect_encoding') 
+            && function_exists('mb_convert_encoding')) {
+
+            // mb_detect_encoding isn't very reliable, to say the least
+            // detection should still work with a sufficient sample of ascii characters
+            $encoding = mb_detect_encoding($sample);
+
+            // mb_detect_encoding() will return FALSE if detection fails
+            // don't attempt conversion if that's the case
+            if ($encoding != 'ASCII' && $encoding != 'UTF-8' && $encoding !== false) {
+            
+                if (function_exists('mb_list_encodings')) {
+ 
+                    // verify the encoding exists in mb_list_encodings
+                    if (in_array($encoding, mb_list_encodings())) {
+                        $sample = mb_convert_encoding($sample, 'UTF-8', $encoding);
+                    }
+
+                    // if the previous condition failed:
+                    // somehow we detected an encoding that also we don't support
+
+                } else {
+                    // php 4 doesnt have mb_list_encodings()
+                    // so attempt with error suppression
+                    $sample = @mb_convert_encoding($sample, 'UTF-8', $encoding);
+                }
+            }
+        }
+
+        $sample_obj = new Text_LanguageDetect_Parser($sample, $this->_db_filename, $this->_unicode_db_filename);
+        $sample_obj->prepareTrigram();
+        if ($this->_use_unicode_narrowing) {
+            $sample_obj->prepareUnicode();
+        }
+        $sample_obj->setPadStart(!$this->_perl_compatible);
+        $sample_obj->analyze();
+
+        $trigram_freqs =& $sample_obj->getTrigramRanks();
+        $trigram_count = count($trigram_freqs);
+
+        if ($trigram_count == 0) {
+            return array();
+        }
+
+        $scores = array();
+
+        // use unicode block detection to narrow down the possibilities
+        if ($this->_use_unicode_narrowing) {
+            $blocks =& $sample_obj->getUnicodeBlocks();
+
+            if (is_array($blocks)) {
+                $present_blocks = array_keys($blocks);
+            } else {
+                throw new Exception('Error during block detection');
+            }
+
+            $possible_langs = array();
+
+            foreach ($present_blocks as $blockname) {
+                if (isset($this->_unicode_map[$blockname])) {
+
+                    $possible_langs = array_merge(
+                        $possible_langs,
+                        array_keys($this->_unicode_map[$blockname])
+                    );
+
+                    // todo: faster way to do this?
+                }
+            }
+
+            // could also try an intersect operation rather than a union
+            // in other words, choose languages whose trigrams contain 
+            // ALL of the unicode blocks found in this sample
+            // would improve speed but would be completely thrown off by an
+            // unexpected character, like an umlaut appearing in english text
+
+            $possible_langs = array_intersect(
+                        array_keys($this->_lang_db),
+                        array_unique($possible_langs)
+            );
+
+            // needs to intersect it with the keys of _lang_db in case 
+            // languages have been omitted
+
+        // or just try 'em all
+        } else {
+            $possible_langs = array_keys($this->_lang_db);
+        }
+
+
+        foreach ($possible_langs as $lang) {
+            $scores[$lang] =
+                $this->_normalize_score(
+                        $this->_distance($this->_lang_db[$lang], $trigram_freqs),
+                        $trigram_count);
+        }
+
+        unset($sample_obj);
+
+        if ($this->_perl_compatible) {
+            asort($scores);
+        } else {
+            arsort($scores);
+        }
+
+        // todo: drop languages with a score of $this->_max_score?
+
+        // limit the number of returned scores
+        if ($limit && is_numeric($limit)) {
+            $limited_scores = array();
+
+            $i = 0;
+
+            foreach ($scores as $key => $value) {
+                if ($i++ >= $limit) {
+                    break;
+                }
+
+                $limited_scores[$key] = $value;
+            }
+
+            return $limited_scores;
+        } else {
+            return $scores;
+        }
+    }
+
+    /**
+     * Returns only the most similar language to the text sample
+     *
+     * Calls $this->detect() and returns only the top result
+     * 
+     * @access   public
+     * @param    string    $sample    text to detect the language of
+     * @return   string               the name of the most likely language
+     *                                or null if no language is similar
+     * @see      detect()
+     * @throws   PEAR_Error
+     */
+    function detectSimple($sample)
+    {
+        $scores = $this->detect($sample, 1);
+
+        // if top language has the maximum possible score,
+        // then the top score will have been picked at random
+        if (    !is_array($scores) 
+                || empty($scores) 
+                || current($scores) == $this->_max_score) {
+
+            return null;
+
+        } else {
+            return ucfirst(key($scores));
+        }
+    }
+
+    /**
+     * Returns an array containing the most similar language and a confidence
+     * rating
+     * 
+     * Confidence is a simple measure calculated from the similarity score
+     * minus the similarity score from the next most similar language
+     * divided by the highest possible score. Languages that have closely
+     * related cousins (e.g. Norwegian and Danish) should generally have lower
+     * confidence scores.
+     *
+     * The similarity score answers the question "How likely is the text the
+     * returned language regardless of the other languages considered?" The 
+     * confidence score is one way of answering the question "how likely is the
+     * text the detected language relative to the rest of the language model
+     * set?"
+     *
+     * To see how similar languages are a priori, see languageSimilarity()
+     * 
+     * @access   public
+     * @param    string    $sample    text for which language will be detected
+     * @return   array     most similar language, score and confidence rating
+     *                     or null if no language is similar
+     * @see      detect()
+     * @throws   PEAR_Error
+     */
+    function detectConfidence($sample)
+    {
+        $scores = $this->detect($sample, 2);
+
+        // if most similar language has the max score, it 
+        // will have been picked at random
+        if (    !is_array($scores) 
+                || empty($scores) 
+                || current($scores) == $this->_max_score) {
+
+            return null;
+        }
+
+        $arr['language'] = ucfirst(key($scores));
+        $arr['similarity'] = current($scores);
+        if (next($scores) !== false) { // if false then no next element
+            // the goal is to return a higher value if the distance between
+            // the similarity of the first score and the second score is high
+
+            if ($this->_perl_compatible) {
+
+                $arr['confidence'] =
+                    (current($scores) - $arr['similarity']) / $this->_max_score;
+
+            } else {
+
+                $arr['confidence'] = $arr['similarity'] - current($scores);
+
+            }
+
+        } else {
+            $arr['confidence'] = null;
+        }
+
+        return $arr;
+    }
+
+    /**
+     * Returns the distribution of unicode blocks in a given utf8 string
+     *
+     * For the block name of a single char, use unicodeBlockName()
+     * 
+     * @access public
+     * @param string $str input string. Must be ascii or utf8
+     * @param bool $skip_symbols if true, skip ascii digits, symbols and 
+     *                           non-printing characters. Includes spaces,
+     *                           newlines and common punctutation characters.
+     * @return array
+     * @throws PEAR_Error
+     */
+    function detectUnicodeBlocks($str, $skip_symbols)
+    {
+        // input check
+        if (!is_bool($skip_symbols)) {
+            throw new Exception('Second parameter must be boolean');
+        } 
+
+        if (!is_string($str)) {
+            throw new Exception('First parameter was not a string');
+        }
+
+        $sample_obj = new Text_LanguageDetect_Parser($str, $this->_db_filename, $this->_unicode_db_filename);
+        $sample_obj->prepareUnicode();
+        $sample_obj->prepareTrigram(false);
+        $sample_obj->setUnicodeSkipSymbols($skip_symbols);
+        $sample_obj->analyze();
+        $blocks =& $sample_obj->getUnicodeBlocks();
+        unset($sample_obj);
+        return $blocks;
+    }
+
+    /**
+     * Returns the block name for a given unicode value
+     *
+     * If passed a string, will assume it is being passed a UTF8-formatted 
+     * character and will automatically convert. Otherwise it will assume it
+     * is being passed a numeric unicode value.
+     *
+     * Make sure input is of the correct type!
+     *
+     * @access public
+     * @param mixed $unicode unicode value or utf8 char
+     * @return mixed the block name string or false if not found
+     * @throws PEAR_Error
+     */
+    function unicodeBlockName($unicode) {
+        if (is_string($unicode)) {
+            // assume it is being passed a utf8 char, so convert it
+
+            // input check
+            if ($this->utf8strlen($unicode) > 1) {
+                throw new Exception('Pass this function only a single char');
+            }
+
+            $unicode = $this->_utf8char2unicode($unicode);
+
+            if ($unicode == -1) {
+                throw new Exception('Malformatted char');
+            }
+
+        // input check
+        } elseif (!is_int($unicode)) {
+            throw new Exception('Input must be of type string or int.');
+        }
+
+        $blocks =& $this->_read_unicode_block_db();
+
+        $result = $this->_unicode_block_name($unicode, $blocks);
+
+        if ($result == -1) {
+            return false;
+        } else {
+            return $result[2];
+        }
+    }
+
+    /**
+     * Searches the unicode block database
+     *
+     * Returns the block name for a given unicode value. unicodeBlockName() is
+     * the public interface for this function, which does input checks which
+     * this function omits for speed.
+     *
+     * @access  protected
+     * @param   int     $unicode the unicode value
+     * @param   array   &$blocks the block database
+     * @param   int     $block_count the number of defined blocks in the database
+     * @see     unicodeBlockName()
+     */
+    function _unicode_block_name($unicode, &$blocks, $block_count = -1) {
+        // for a reference, see 
+        // http://www.unicode.org/Public/UNIDATA/Blocks.txt
+
+        // assume that ascii characters are the most common
+        // so try it first for efficiency
+        if ($unicode <= $blocks[0][1]) {
+            return $blocks[0];
+        }
+
+        // the optional $block_count param is for efficiency
+        // so we this function doesn't have to run count() every time
+        if ($block_count != -1) {
+            $high = $block_count - 1;
+        } else {
+            $high = count($blocks) - 1;
+        }
+
+        $low = 1; // start with 1 because ascii was 0
+
+        // your average binary search algorithm
+        while ($low <= $high) {
+            $mid = floor(($low + $high) / 2);
+
+            // if it's lower than the lower bound
+            if ($unicode < $blocks[$mid][0]) {
+                $high = $mid - 1;
+
+            // if it's higher than the upper bound
+            } elseif ($unicode > $blocks[$mid][1]) {
+                $low = $mid + 1;
+
+            // found it
+            } else {
+                return $blocks[$mid];
+            }
+        }
+
+        // failed to find the block 
+        return -1;
+
+        // todo: differentiate when it's out of range or when it falls 
+        //       into an unassigned range?
+    }
+
+    /**
+     * Brings up the unicode block database
+     *
+     * @access protected
+     * @return array the database of unicode block definitions
+     * @throws PEAR_Error
+     */
+    function &_read_unicode_block_db() {
+        // since the unicode definitions are always going to be the same,
+        // might as well share the memory for the db with all other instances
+        // of this class
+        static $data;
+
+        if (!isset($data)) {
+            $data = $this->_readdb($this->_unicode_db_filename);
+        }
+
+        return $data;
+    }
+
+    /**
+     * Calculate the similarities between the language models
+     * 
+     * Use this function to see how similar languages are to each other.
+     *
+     * If passed 2 language names, will return just those languages compared.
+     * If passed 1 language name, will return that language compared to
+     * all others.
+     * If passed none, will return an array of every language model compared 
+     * to every other one.
+     *
+     * @access  public
+     * @param   string   $lang1   the name of the first language to be compared
+     * @param   string   $lang2   the name of the second language to be compared
+     * @return  array    scores of every language compared
+     *                   or the score of just the provided languages
+     *                   or null if one of the supplied languages does not exist
+     * @throws  PEAR_Error
+     */
+    function languageSimilarity($lang1 = null, $lang2 = null)
+    {
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        }
+
+        if ($lang1 != null) {
+            $lang1 = strtolower($lang1);
+
+            // check if language model exists
+            if (!isset($this->_lang_db[$lang1])) {
+                return null;
+            }
+
+            if ($lang2 != null) {
+
+                // can't only set the second param
+                if ($lang1 == null) {
+                    return null;
+                // check if language model exists
+                } elseif (!isset($this->_lang_db[$lang2])) {
+                    return null;
+                }
+
+                $lang2 = strtolower($lang2);
+
+                // compare just these two languages
+                return $this->_normalize_score(
+                    $this->_distance(
+                        $this->_lang_db[$lang1],
+                        $this->_lang_db[$lang2]
+                    )
+                );
+
+
+            // compare just $lang1 to all languages
+            } else {
+                $return_arr = array();
+                foreach ($this->_lang_db as $key => $value) {
+                    if ($key != $lang1) { // don't compare a language to itself
+                        $return_arr[$key] = $this->_normalize_score(
+                            $this->_distance($this->_lang_db[$lang1], $value));
+                    }
+                }
+                asort($return_arr);
+
+                return $return_arr;
+            }
+
+
+        // compare all languages to each other
+        } else {
+            $return_arr = array();
+            foreach (array_keys($this->_lang_db) as $lang1) {
+                foreach (array_keys($this->_lang_db) as $lang2) {
+
+                    // skip comparing languages to themselves
+                    if ($lang1 != $lang2) { 
+                    
+                        // don't re-calculate what's already been done
+                        if (isset($return_arr[$lang2][$lang1])) {
+
+                            $return_arr[$lang1][$lang2] =
+                                $return_arr[$lang2][$lang1];
+
+                        // calculate
+                        } else {
+
+                            $return_arr[$lang1][$lang2] = 
+                                $this->_normalize_score(
+                                        $this->_distance(
+                                            $this->_lang_db[$lang1],
+                                            $this->_lang_db[$lang2]
+                                        )
+                                );
+
+                        }
+                    }
+                }
+            }
+            return $return_arr;
+        }
+    }
+
+    /**
+     * Cluster known languages according to languageSimilarity()
+     *
+     * WARNING: this method is EXPERIMENTAL. It is not recommended for common
+     * use, and it may disappear or its functionality may change in future
+     * releases without notice.
+     *
+     * Uses a nearest neighbor technique to generate the maximum possible
+     * number of dendograms from the similarity data.
+     *
+     * @access      public
+     * @return      array language cluster data
+     * @throws      PEAR_Error
+     * @see         languageSimilarity()
+     * @deprecated  this function will eventually be removed and placed into 
+     *              the model generation class
+     */
+    function clusterLanguages()
+    {
+        // todo: set the maximum number of clusters
+
+        // setup check
+        if (!$this->_setup_ok($err)) {
+            return $err;
+        }
+
+        // return cached result, if any
+        if (isset($this->_clusters)) {
+            return $this->_clusters;
+        }
+
+        $langs = array_keys($this->_lang_db);
+
+        $arr = $this->languageSimilarity();
+
+        sort($langs);
+
+        foreach ($langs as $lang) {
+            if (!isset($this->_lang_db[$lang])) {
+                throw new Exception("missing $lang!\n");
+            }
+        }
+
+        // http://www.psychstat.missouristate.edu/multibook/mlt04m.html
+        foreach ($langs as $old_key => $lang1) {
+            $langs[$lang1] = $lang1;
+            unset($langs[$old_key]);
+        }
+        
+        $i = 0;
+        while (count($langs) > 2 && $i++ < 200) {
+            $highest_score = -1;
+            $highest_key1 = '';
+            $highest_key2 = '';
+            foreach ($langs as $lang1) {
+                foreach ($langs as $lang2) {
+                    if (    $lang1 != $lang2 
+                            && $arr[$lang1][$lang2] > $highest_score) {
+                        $highest_score = $arr[$lang1][$lang2];
+                        $highest_key1 = $lang1;
+                        $highest_key2 = $lang2;
+                    }
+                }
+            }
+            
+            if (!$highest_key1) {
+                // should not ever happen
+                throw new Exception("no highest key? (step: $i)");
+            }
+
+            if ($highest_score == 0) {
+                // languages are perfectly dissimilar
+                break;
+            }
+
+            // $highest_key1 and $highest_key2 are most similar
+            $sum1 = array_sum($arr[$highest_key1]);
+            $sum2 = array_sum($arr[$highest_key2]);
+
+            // use the score for the one that is most similar to the rest of 
+            // the field as the score for the group
+            // todo: could try averaging or "centroid" method instead
+            // seems like that might make more sense
+            // actually nearest neighbor may be better for binary searching
+
+
+            // for "Complete Linkage"/"furthest neighbor"
+            // sign should be <
+            // for "Single Linkage"/"nearest neighbor" method
+            // should should be >
+            // results seem to be pretty much the same with either method
+
+            // figure out which to delete and which to replace
+            if ($sum1 > $sum2) {
+                $replaceme = $highest_key1;
+                $deleteme = $highest_key2;
+            } else {
+                $replaceme = $highest_key2;
+                $deleteme = $highest_key1;
+            }
+
+            $newkey = $replaceme . ':' . $deleteme;
+
+            // $replaceme is most similar to remaining languages
+            // replace $replaceme with '$newkey', deleting $deleteme
+
+            // keep a record of which fork is really which language
+            $really_lang = $replaceme;
+            while (isset($really_map[$really_lang])) {
+                $really_lang = $really_map[$really_lang];
+            } 
+            $really_map[$newkey] = $really_lang;
+
+
+            // replace the best fitting key, delete the other
+            foreach ($arr as $key1 => $arr2) {
+                foreach ($arr2 as $key2 => $value2) {
+                    if ($key2 == $replaceme) {
+                        $arr[$key1][$newkey] = $arr[$key1][$key2];
+                        unset($arr[$key1][$key2]);
+                        // replacing $arr[$key1][$key2] with $arr[$key1][$newkey]
+                    } 
+                    
+                    if ($key1 == $replaceme) {
+                        $arr[$newkey][$key2] = $arr[$key1][$key2];
+                        unset($arr[$key1][$key2]);
+                        // replacing $arr[$key1][$key2] with $arr[$newkey][$key2]
+                    }
+
+                    if ($key1 == $deleteme || $key2 == $deleteme) {
+                        // deleting $arr[$key1][$key2]
+                        unset($arr[$key1][$key2]);
+                    }
+                }
+            }
+                        
+
+            unset($langs[$highest_key1]);
+            unset($langs[$highest_key2]);
+            $langs[$newkey] = $newkey;
+
+
+            // some of these may be overkill
+            $result_data[$newkey] = array(
+                                'newkey' => $newkey,
+                                'count' => $i,
+                                'diff' => abs($sum1 - $sum2),
+                                'score' => $highest_score,
+                                'bestfit' => $replaceme,
+                                'otherfit' => $deleteme,
+                                'really' => $really_lang,
+                            );
+        }
+
+        $return_val = array(
+                'open_forks' => $langs, 
+                        // the top level of clusters
+                        // clusters that are mutually exclusive
+                        // or specified by a specific maximum
+
+                'fork_data' => $result_data,
+                        // data for each split
+
+                'name_map' => $really_map,
+                        // which cluster is really which language
+                        // using the nearest neighbor technique, the cluster
+                        // inherits all of the properties of its most-similar member
+                        // this keeps track
+            );
+
+
+        // saves the result in the object
+        $this->_clusters = $return_val;
+
+        return $return_val;
+    }
+
+
+    /**
+     * Perform an intelligent detection based on clusterLanguages()
+     *
+     * WARNING: this method is EXPERIMENTAL. It is not recommended for common
+     * use, and it may disappear or its functionality may change in future
+     * releases without notice.
+     *
+     * This compares the sample text to top the top level of clusters. If the 
+     * sample is similar to the cluster it will drop down and compare it to the
+     * languages in the cluster, and so on until it hits a leaf node.
+     *
+     * this should find the language in considerably fewer compares 
+     * (the equivalent of a binary search), however clusterLanguages() is costly
+     * and the loss of accuracy from this technique is significant.
+     *
+     * This method may need to be 'fuzzier' in order to become more accurate.
+     *
+     * This function could be more useful if the universe of possible languages
+     * was very large, however in such cases some method of Bayesian inference
+     * might be more helpful.
+     *
+     * @see     clusterLanguages()
+     * @access  public
+     * @param   string $str input string
+     * @return  array language scores (only those compared)
+     * @throws  PEAR_Error
+     */
+    function clusteredSearch($str)
+    {
+
+        // input check
+        if (!Text_LanguageDetect_Parser::validateString($str)) {
+            return array();
+        }
+
+        // clusterLanguages() will return a cached result if possible
+        // so it's safe to call it every time
+        $result = $this->clusterLanguages();
+
+        $dendogram_start = $result['open_forks'];
+        $dendogram_data  = $result['fork_data'];
+        $dendogram_alias = $result['name_map'];
+
+        $sample_obj = new Text_LanguageDetect_Parser($str, $this->_db_filename, $this->_unicode_db_filename);
+        $sample_obj->prepareTrigram();
+        $sample_obj->setPadStart(!$this->_perl_compatible);
+        $sample_obj->analyze();
+        $sample_result = $sample_obj->getTrigramRanks();
+        $sample_count  = count($sample_result);
+
+        // input check
+        if ($sample_count == 0) {
+            return array();
+        }
+
+        $i = 0; // counts the number of steps
+        
+        foreach ($dendogram_start as $lang) {
+            if (isset($dendogram_alias[$lang])) {
+                $lang_key = $dendogram_alias[$lang];
+            } else {
+                $lang_key = $lang;
+            }
+
+            $scores[$lang] = $this->_normalize_score(
+                $this->_distance($this->_lang_db[$lang_key], $sample_result),
+                $sample_count);
+
+            $i++;
+        }
+
+        if ($this->_perl_compatible) {
+            asort($scores);
+        } else {
+            arsort($scores);
+        }
+
+        $top_score = current($scores);
+        $top_key = key($scores);
+
+        // of starting forks, $top_key is the most similar to the sample
+
+        $cur_key = $top_key;
+        while (isset($dendogram_data[$cur_key])) {
+            $lang1 = $dendogram_data[$cur_key]['bestfit'];
+            $lang2 = $dendogram_data[$cur_key]['otherfit'];
+            foreach (array($lang1, $lang2) as $lang) {
+                if (isset($dendogram_alias[$lang])) {
+                    $lang_key = $dendogram_alias[$lang];
+                } else {
+                    $lang_key = $lang;
+                }
+
+                $scores[$lang] = $this->_normalize_score(
+                    $this->_distance($this->_lang_db[$lang_key], $sample_result),
+                    $sample_count);
+
+                //todo: does not need to do same comparison again
+            }
+
+            $i++;
+
+            if ($scores[$lang1] > $scores[$lang2]) {
+                $cur_key = $lang1;
+                $loser_key = $lang2;
+            } else {
+                $cur_key = $lang2;
+                $loser_key = $lang1;
+            }
+
+            $diff = $scores[$cur_key] - $scores[$loser_key];
+
+            // $cur_key ({$dendogram_alias[$cur_key]}) wins 
+            // over $loser_key ({$dendogram_alias[$loser_key]}) 
+            // with a difference of $diff
+        }
+
+        // found result in $i compares
+
+        // rather than sorting the result, preserve it so that you can see
+        // which paths the algorithm decided to take along the tree
+
+        // but sometimes the last item is only the second highest
+        if (   ($this->_perl_compatible  && (end($scores) > prev($scores)))
+            || (!$this->_perl_compatible && (end($scores) < prev($scores)))) {
+
+            $real_last_score = current($scores);
+            $real_last_key = key($scores);
+
+            // swaps the 2nd-to-last item for the last item
+            unset($scores[$real_last_key]);
+            $scores[$real_last_key] = $real_last_score;
+        }
+            
+
+        if (!$this->_perl_compatible) {
+            $scores = array_reverse($scores, true);
+            // second param requires php > 4.0.3
+        }
+
+        return $scores;
+    }
+
+    /**
+     * ut8-safe strlen()
+     *
+     * Returns the numbers of characters (not bytes) in a utf8 string
+     *
+     * @static
+     * @access  public
+     * @param   string $str string to get the length of
+     * @return  int         number of chars
+     */
+    function utf8strlen($str)
+    {
+        // utf8_decode() will convert unknown chars to '?', which is actually
+        // ideal for counting.
+
+        return strlen(utf8_decode($str));
+
+        // idea stolen from dokuwiki
+    }
+
+    /**
+     * Returns the unicode value of a utf8 char
+     *
+     * @access  protected
+     * @param   string $char a utf8 (possibly multi-byte) char
+     * @return  int          unicode value or -1 if malformatted
+     */
+    function _utf8char2unicode($char) {
+
+        // strlen() here will actually get the binary length of a single char
+        switch (strlen($char)) {
+
+            // for a reference, see http://en.wikipedia.org/wiki/UTF-8
+
+            case 1:
+                // normal ASCII-7 byte
+                // 0xxxxxxx -->  0xxxxxxx
+                return ord($char{0});
+
+            case 2:
+                // 2 byte unicode
+                // 110zzzzx 10xxxxxx --> 00000zzz zxxxxxxx
+                $z = (ord($char{0}) & 0x000001F) << 6;
+                $x = (ord($char{1}) & 0x0000003F);
+
+                return ($z | $x);
+
+            case 3:
+                // 3 byte unicode
+                // 1110zzzz 10zxxxxx 10xxxxxx --> zzzzzxxx xxxxxxxx 
+                $z =  (ord($char{0}) & 0x0000000F) << 12;
+                $x1 = (ord($char{1}) & 0x0000003F) << 6;
+                $x2 = (ord($char{2}) & 0x0000003F);
+
+                return ($z | $x1 | $x2);
+
+            case 4:
+                // 4 byte unicode
+                // 11110zzz 10zzxxxx 10xxxxxx 10xxxxxx -->
+                // 000zzzzz xxxxxxxx xxxxxxxx
+                $z1 = (ord($char{0}) & 0x00000007) << 18;
+                $z2 = (ord($char{1}) & 0x0000003F) << 12;
+                $x1 = (ord($char{2}) & 0x0000003F) << 6;
+                $x2 = (ord($char{3}) & 0x0000003F);
+
+                return ($z1 | $z2 | $x1 | $x2);
+
+            default:
+                // error: malformatted char?
+                return -1;
+        }
+    }
+
+    /**
+     * utf8-safe fast character iterator
+     *
+     * Will get the next character starting from $counter, which will then be
+     * incremented. If a multi-byte char the bytes will be concatenated and 
+     * $counter will be incremeted by the number of bytes in the char.
+     *
+     * @access  private
+     * @param   string  &$str        the string being iterated over
+     * @param   int     &$counter    the iterator, will increment by reference
+     * @param   bool    $special_convert whether to do special conversions
+     * @return  char    the next (possibly multi-byte) char from $counter
+     */
+    function _next_char(&$str, &$counter, $special_convert = false)
+    {
+
+        $char = $str{$counter++};
+        $ord = ord($char);
+
+        // for a description of the utf8 system see
+        // http://www.phpclasses.org/browse/file/5131.html
+
+        // normal ascii one byte char
+        if ($ord <= 127) {
+
+            // special conversions needed for this package
+            // (that only apply to regular ascii characters)
+            // lower case, and convert all non-alphanumeric characters
+            // other than "'" to space
+            if ($special_convert && $char != ' ' && $char != "'") {
+                if ($ord >= 65 && $ord <= 90) { // A-Z
+                    $char = chr($ord + 32); // lower case
+                } elseif ($ord < 97 || $ord > 122) { // NOT a-z
+                    $char = ' '; // convert to space
+                }
+            }
+
+            return $char;
+
+        // multi-byte chars
+        } elseif ($ord >> 5 == 6) { // two-byte char
+            $nextchar = $str{$counter++}; // get next byte
+
+            // lower-casing of non-ascii characters is still incomplete
+
+            if ($special_convert) {
+                // lower case latin accented characters
+                if ($ord == 195) {
+                    $nextord = ord($nextchar);
+                    $nextord_adj = $nextord + 64;
+                    // for a reference, see 
+                    // http://www.ramsch.org/martin/uni/fmi-hp/iso8859-1.html
+
+                    // &Agrave; - &THORN; but not &times;
+                    if (    $nextord_adj >= 192
+                            && $nextord_adj <= 222 
+                            && $nextord_adj != 215) {
+
+                        $nextchar = chr($nextord + 32); 
+                    }
+
+                // lower case cyrillic alphabet
+                } elseif ($ord == 208) {
+                    $nextord = ord($nextchar);
+                    // if A - Pe
+                    if ($nextord >= 144 && $nextord <= 159) {
+                        // lower case
+                        $nextchar = chr($nextord + 32);
+
+                    // if Er - Ya
+                    } elseif ($nextord >= 160 && $nextord <= 175) {
+                        // lower case
+                        $char = chr(209); // == $ord++
+                        $nextchar = chr($nextord - 32);
+                    }
+                }
+            }
+
+            // tag on next byte
+            return $char . $nextchar; 
+
+        } elseif ($ord >> 4  == 14) { // three-byte char
+            
+            // tag on next 2 bytes
+            return $char . $str{$counter++} . $str{$counter++}; 
+
+        } elseif ($ord >> 3 == 30) { // four-byte char
+
+            // tag on next 3 bytes
+            return $char . $str{$counter++} . $str{$counter++} . $str{$counter++};
+
+        } else {
+            // error?
+        }
+    }
+
+}
+
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+?>
diff --git a/inc/3rdparty/libraries/language-detect/Parser.php b/inc/3rdparty/libraries/language-detect/Parser.php
new file mode 100644
index 00000000..7f15fa98
--- /dev/null
+++ b/inc/3rdparty/libraries/language-detect/Parser.php
@@ -0,0 +1,354 @@
+<?php
+
+/**
+ * This class represents a text sample to be parsed.
+ *
+ * @category    Text
+ * @package     Text_LanguageDetect
+ * @author      Nicholas Pisarro
+ * @copyright   2006
+ * @license     BSD
+ * @version     CVS: $Id: Parser.php,v 1.5 2006/03/11 05:45:05 taak Exp $
+ * @link        http://pear.php.net/package/Text_LanguageDetect/
+ * @link        http://langdetect.blogspot.com/
+ */
+
+/**
+ * This class represents a text sample to be parsed.
+ *
+ * This separates the analysis of a text sample from the primary LanguageDetect
+ * class. After a new profile has been built, the data can be retrieved using
+ * the accessor functions.
+ *
+ * This class is intended to be used by the Text_LanguageDetect class, not 
+ * end-users.
+ *
+ * @category    Text
+ * @package     Text_LanguageDetect
+ * @author      Nicholas Pisarro
+ * @copyright   2006
+ * @license     BSD
+ * @version     release: 0.2.3
+ */
+class Text_LanguageDetect_Parser extends Text_LanguageDetect
+{
+    /**
+     * the piece of text being parsed
+     *
+     * @access  private
+     * @var     string
+     */
+    var $_string;
+
+    /**
+     * stores the trigram frequencies of the sample
+     *
+     * @access  private
+     * @var     string
+     */
+    var $_trigrams = array();
+
+    /**
+     * stores the trigram ranks of the sample
+     *
+     * @access  private
+     * @var     array
+     */
+    var $_trigram_ranks = array();
+
+    /**
+     * stores the unicode blocks of the sample
+     *
+     * @access  private
+     * @var     array
+     */
+    var $_unicode_blocks = array();
+    
+    /**
+     * Whether the parser should compile the unicode ranges
+     * 
+     * @access  private
+     * @var     bool
+     */
+    var $_compile_unicode = false;
+
+    /**
+     * Whether the parser should compile trigrams
+     *
+     * @access  private
+     * @var     bool
+     */
+    var $_compile_trigram = false;
+
+    /**
+     * Whether the trigram parser should pad the beginning of the string
+     *
+     * @access  private
+     * @var     bool
+     */
+    var $_trigram_pad_start = false;
+
+    /**
+     * Whether the unicode parser should skip non-alphabetical ascii chars
+     *
+     * @access  private
+     * @var     bool
+     */
+    var $_unicode_skip_symbols = true;
+
+    /**
+     * Constructor
+     *
+     * @access  private
+     * @param   string  $string     string to be parsed
+     */
+    function Text_LanguageDetect_Parser($string, $db=null, $unicode_db=null) {
+                if (isset($db)) $this->_db_filename = $db;
+                if (isset($unicode_db)) $this->_unicode_db_filename = $unicode_db;      
+        $this->_string = $string;
+    }
+
+    /**
+     * Returns true if a string is suitable for parsing
+     *
+     * @static
+     * @access  public
+     * @param   string  $str    input string to test
+     * @return  bool            true if acceptable, false if not
+     */
+    function validateString($str) {
+        if (!empty($str) && strlen($str) > 3 && preg_match('/\S/', $str)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * turn on/off trigram counting
+     *
+     * @access  public
+     * @param   bool    $bool true for on, false for off
+     */
+    function prepareTrigram($bool = true)
+    {
+        $this->_compile_trigram = $bool;
+    }
+
+    /**
+     * turn on/off unicode block counting
+     *
+     * @access  public
+     * @param   bool    $bool true for on, false for off
+     */
+    function prepareUnicode($bool = true)
+    {
+        $this->_compile_unicode = $bool;
+    }
+
+    /**
+     * turn on/off padding the beginning of the sample string
+     *
+     * @access  public
+     * @param   bool    $bool true for on, false for off
+     */
+    function setPadStart($bool = true)
+    {
+        $this->_trigram_pad_start = $bool;
+    }
+
+    /**
+     * Should the unicode block counter skip non-alphabetical ascii chars?
+     *
+     * @access  public
+     * @param   bool    $bool true for on, false for off
+     */
+    function setUnicodeSkipSymbols($bool = true)
+    {
+        $this->_unicode_skip_symbols = $bool;
+    }
+
+    /**
+     * Returns the trigram ranks for the text sample
+     *
+     * @access  public
+     * @return  array    trigram ranks in the text sample
+     */
+    function &getTrigramRanks()
+    {
+        return $this->_trigram_ranks;
+    }
+
+    /**
+     * Return the trigram freqency table
+     *
+     * only used in testing to make sure the parser is working
+     *
+     * @access  public
+     * @return  array    trigram freqencies in the text sample
+     */
+    function &getTrigramFreqs()
+    {
+        return $this->_trigram;
+    }
+
+    /**
+     * returns the array of unicode blocks
+     *
+     * @access  public
+     * @return  array   unicode blocks in the text sample
+     */
+    function &getUnicodeBlocks()
+    {
+        return $this->_unicode_blocks;
+    }
+
+    /**
+     * Executes the parsing operation
+     * 
+     * Be sure to call the set*() functions to set options and the 
+     * prepare*() functions first to tell it what kind of data to compute
+     *
+     * Afterwards the get*() functions can be used to access the compiled
+     * information.
+     *
+     * @access public
+     */
+    function analyze()
+    {
+        $len = strlen($this->_string);
+        $byte_counter = 0;
+
+
+        // unicode startup
+        if ($this->_compile_unicode) {
+            $blocks =& $this->_read_unicode_block_db();
+
+            $block_count = count($blocks);
+
+            $skipped_count = 0;
+            $unicode_chars = array();
+        }
+
+        // trigram startup
+        if ($this->_compile_trigram) {
+            // initialize them as blank so the parser will skip the first two
+            // (since it skips trigrams with more than  2 contiguous spaces)
+            $a = ' ';
+            $b = ' ';
+
+            // kludge
+            // if it finds a valid trigram to start and the start pad option is
+            // off, then set a variable that will be used to reduce this
+            // trigram after parsing has finished
+            if (!$this->_trigram_pad_start) {
+                $a = $this->_next_char($this->_string, $byte_counter, true);
+
+                if ($a != ' ') {
+                    $b = $this->_next_char($this->_string, $byte_counter, true);
+                    $dropone = " $a$b";
+                }
+
+                $byte_counter = 0;
+                $a = ' ';
+                $b = ' ';
+            }
+        }
+
+        while ($byte_counter < $len) {
+            $char = $this->_next_char($this->_string, $byte_counter, true);
+
+
+            // language trigram detection
+            if ($this->_compile_trigram) {
+                if (!($b == ' ' && ($a == ' ' || $char == ' '))) {
+                    if (!isset($this->_trigram[$a . $b . $char])) {
+                       $this->_trigram[$a . $b . $char] = 1;
+                    } else {
+                       $this->_trigram[$a . $b . $char]++;
+                    }
+                }
+
+                $a = $b;
+                $b = $char;
+            }
+
+            // unicode block detection
+            if ($this->_compile_unicode) {
+                if ($this->_unicode_skip_symbols
+                        && strlen($char) == 1
+                        && ($char < 'A' || $char > 'z'
+                        || ($char > 'Z' && $char < 'a'))
+                        && $char != "'") {  // does not skip the apostrophe
+                                            // since it's included in the language
+                                            // models
+
+                    $skipped_count++;
+                    continue;
+                }
+
+                // build an array of all the characters
+                if (isset($unicode_chars[$char])) {
+                    $unicode_chars[$char]++;
+                } else {
+                    $unicode_chars[$char] = 1;
+                }
+            }
+
+            // todo: add byte detection here
+        }
+
+        // unicode cleanup
+        if ($this->_compile_unicode) {
+            foreach ($unicode_chars as $utf8_char => $count) {
+                $search_result = $this->_unicode_block_name(
+                        $this->_utf8char2unicode($utf8_char), $blocks, $block_count);
+
+                if ($search_result != -1) {
+                    $block_name = $search_result[2];
+                } else {
+                    $block_name = '[Malformatted]';
+                }
+
+                if (isset($this->_unicode_blocks[$block_name])) {
+                    $this->_unicode_blocks[$block_name] += $count;
+                } else {
+                    $this->_unicode_blocks[$block_name] = $count;
+                }
+            }
+        }
+
+
+        // trigram cleanup
+        if ($this->_compile_trigram) {
+            // pad the end
+            if ($b != ' ') {
+                if (!isset($this->_trigram["$a$b "])) {
+                    $this->_trigram["$a$b "] = 1;
+                } else {
+                    $this->_trigram["$a$b "]++;
+                }
+            }
+
+            // perl compatibility; Language::Guess does not pad the beginning
+            // kludge
+            if (isset($dropone)) {
+                if ($this->_trigram[$dropone] == 1) {
+                    unset($this->_trigram[$dropone]);
+                } else {
+                    $this->_trigram[$dropone]--;
+                }
+            }
+
+            if (!empty($this->_trigram)) {
+                $this->_trigram_ranks = $this->_arr_rank($this->_trigram);
+            } else {
+                $this->_trigram_ranks = array();
+            }
+        }
+    }
+}
+
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+?>
diff --git a/inc/3rdparty/libraries/language-detect/lang.dat b/inc/3rdparty/libraries/language-detect/lang.dat
new file mode 100644
index 00000000..c2a44f56
--- /dev/null
+++ b/inc/3rdparty/libraries/language-detect/lang.dat
@@ -0,0 +1 @@
+a:2:{s:7:"trigram";a:52:{s:8:"albanian";a:300:{s:4:"të ";s:1:"0";s:4:" të";s:1:"1";s:4:"në ";s:1:"2";s:4:"për";s:1:"3";s:4:" pë";s:1:"4";s:3:" e ";s:1:"5";s:3:"sht";s:1:"6";s:4:" në";s:1:"7";s:3:" sh";s:1:"8";s:3:"se ";s:1:"9";s:3:"et ";s:2:"10";s:4:"ë s";s:2:"11";s:4:"ë t";s:2:"12";s:3:" se";s:2:"13";s:3:"he ";s:2:"14";s:4:"jë ";s:2:"15";s:4:"ër ";s:2:"16";s:3:"dhe";s:2:"17";s:3:" pa";s:2:"18";s:4:"ë n";s:2:"19";s:4:"ë p";s:2:"20";s:4:" që";s:2:"21";s:3:" dh";s:2:"22";s:4:"një";s:2:"23";s:4:"ë m";s:2:"24";s:3:" nj";s:2:"25";s:4:"ësh";s:2:"26";s:3:"in ";s:2:"27";s:3:" me";s:2:"28";s:4:"që ";s:2:"29";s:3:" po";s:2:"30";s:3:"e n";s:2:"31";s:3:"e t";s:2:"32";s:3:"ish";s:2:"33";s:4:"më ";s:2:"34";s:4:"së ";s:2:"35";s:3:"me ";s:2:"36";s:4:"htë";s:2:"37";s:3:" ka";s:2:"38";s:3:" si";s:2:"39";s:3:"e k";s:2:"40";s:3:"e p";s:2:"41";s:3:" i ";s:2:"42";s:4:"anë";s:2:"43";s:3:"ar ";s:2:"44";s:3:" nu";s:2:"45";s:3:"und";s:2:"46";s:3:"ve ";s:2:"47";s:4:" ës";s:2:"48";s:3:"e s";s:2:"49";s:4:" më";s:2:"50";s:3:"nuk";s:2:"51";s:3:"par";s:2:"52";s:3:"uar";s:2:"53";s:3:"uk ";s:2:"54";s:3:"jo ";s:2:"55";s:4:"rë ";s:2:"56";s:3:"ta ";s:2:"57";s:4:"ë f";s:2:"58";s:3:"en ";s:2:"59";s:3:"it ";s:2:"60";s:3:"min";s:2:"61";s:3:"het";s:2:"62";s:3:"n e";s:2:"63";s:3:"ri ";s:2:"64";s:3:"shq";s:2:"65";s:4:"ë d";s:2:"66";s:3:" do";s:2:"67";s:3:" nd";s:2:"68";s:3:"sh ";s:2:"69";s:4:"ën ";s:2:"70";s:4:"atë";s:2:"71";s:3:"hqi";s:2:"72";s:3:"ist";s:2:"73";s:4:"ë q";s:2:"74";s:3:" gj";s:2:"75";s:3:" ng";s:2:"76";s:3:" th";s:2:"77";s:3:"a n";s:2:"78";s:3:"do ";s:2:"79";s:3:"end";s:2:"80";s:3:"imi";s:2:"81";s:3:"ndi";s:2:"82";s:3:"r t";s:2:"83";s:3:"rat";s:2:"84";s:4:"ë b";s:2:"85";s:4:"ëri";s:2:"86";s:3:" mu";s:2:"87";s:3:"art";s:2:"88";s:3:"ash";s:2:"89";s:3:"qip";s:2:"90";s:3:" ko";s:2:"91";s:3:"e m";s:2:"92";s:3:"edh";s:2:"93";s:3:"eri";s:2:"94";s:3:"je ";s:2:"95";s:3:"ka ";s:2:"96";s:3:"nga";s:2:"97";s:3:"si ";s:2:"98";s:3:"te ";s:2:"99";s:4:"ë k";s:3:"100";s:4:"ësi";s:3:"101";s:3:" ma";s:3:"102";s:3:" ti";s:3:"103";s:3:"eve";s:3:"104";s:3:"hje";s:3:"105";s:3:"ira";s:3:"106";s:3:"mun";s:3:"107";s:3:"on ";s:3:"108";s:3:"po ";s:3:"109";s:3:"re ";s:3:"110";s:3:" pr";s:3:"111";s:3:"im ";s:3:"112";s:3:"lit";s:3:"113";s:3:"o t";s:3:"114";s:3:"ur ";s:3:"115";s:4:"ë e";s:3:"116";s:4:"ë v";s:3:"117";s:4:"ët ";s:3:"118";s:3:" ku";s:3:"119";s:4:" së";s:3:"120";s:3:"e d";s:3:"121";s:3:"es ";s:3:"122";s:3:"ga ";s:3:"123";s:3:"iti";s:3:"124";s:3:"jet";s:3:"125";s:4:"ndë";s:3:"126";s:3:"oli";s:3:"127";s:3:"shi";s:3:"128";s:3:"tje";s:3:"129";s:4:" bë";s:3:"130";s:3:" z ";s:3:"131";s:3:"gje";s:3:"132";s:3:"kan";s:3:"133";s:3:"shk";s:3:"134";s:4:"ënd";s:3:"135";s:4:"ës ";s:3:"136";s:3:" de";s:3:"137";s:3:" kj";s:3:"138";s:3:" ru";s:3:"139";s:3:" vi";s:3:"140";s:3:"ara";s:3:"141";s:3:"gov";s:3:"142";s:3:"kjo";s:3:"143";s:3:"or ";s:3:"144";s:3:"r p";s:3:"145";s:3:"rto";s:3:"146";s:3:"rug";s:3:"147";s:3:"tet";s:3:"148";s:3:"ugo";s:3:"149";s:3:"ali";s:3:"150";s:3:"arr";s:3:"151";s:3:"at ";s:3:"152";s:3:"d t";s:3:"153";s:3:"ht ";s:3:"154";s:3:"i p";s:3:"155";s:4:"ipë";s:3:"156";s:3:"izi";s:3:"157";s:4:"jnë";s:3:"158";s:3:"n n";s:3:"159";s:3:"ohe";s:3:"160";s:3:"shu";s:3:"161";s:4:"shë";s:3:"162";s:3:"t e";s:3:"163";s:3:"tik";s:3:"164";s:3:"a e";s:3:"165";s:4:"arë";s:3:"166";s:4:"etë";s:3:"167";s:3:"hum";s:3:"168";s:3:"nd ";s:3:"169";s:3:"ndr";s:3:"170";s:3:"osh";s:3:"171";s:3:"ova";s:3:"172";s:3:"rim";s:3:"173";s:3:"tos";s:3:"174";s:3:"va ";s:3:"175";s:3:" fa";s:3:"176";s:3:" fi";s:3:"177";s:3:"a s";s:3:"178";s:3:"hen";s:3:"179";s:3:"i n";s:3:"180";s:3:"mar";s:3:"181";s:3:"ndo";s:3:"182";s:3:"por";s:3:"183";s:3:"ris";s:3:"184";s:3:"sa ";s:3:"185";s:3:"sis";s:3:"186";s:4:"tës";s:3:"187";s:4:"umë";s:3:"188";s:3:"viz";s:3:"189";s:3:"zit";s:3:"190";s:3:" di";s:3:"191";s:3:" mb";s:3:"192";s:3:"aj ";s:3:"193";s:3:"ana";s:3:"194";s:3:"ata";s:3:"195";s:4:"dër";s:3:"196";s:3:"e a";s:3:"197";s:3:"esh";s:3:"198";s:3:"ime";s:3:"199";s:3:"jes";s:3:"200";s:3:"lar";s:3:"201";s:3:"n s";s:3:"202";s:3:"nte";s:3:"203";s:3:"pol";s:3:"204";s:3:"r n";s:3:"205";s:3:"ran";s:3:"206";s:3:"res";s:3:"207";s:4:"rrë";s:3:"208";s:3:"tar";s:3:"209";s:4:"ë a";s:3:"210";s:4:"ë i";s:3:"211";s:3:" at";s:3:"212";s:3:" jo";s:3:"213";s:4:" kë";s:3:"214";s:3:" re";s:3:"215";s:3:"a k";s:3:"216";s:3:"ai ";s:3:"217";s:3:"akt";s:3:"218";s:4:"hë ";s:3:"219";s:4:"hën";s:3:"220";s:3:"i i";s:3:"221";s:3:"i m";s:3:"222";s:3:"ia ";s:3:"223";s:3:"men";s:3:"224";s:3:"nis";s:3:"225";s:3:"shm";s:3:"226";s:3:"str";s:3:"227";s:3:"t k";s:3:"228";s:3:"t n";s:3:"229";s:3:"t s";s:3:"230";s:4:"ë g";s:3:"231";s:4:"ërk";s:3:"232";s:4:"ëve";s:3:"233";s:3:" ai";s:3:"234";s:3:" ci";s:3:"235";s:3:" ed";s:3:"236";s:3:" ja";s:3:"237";s:3:" kr";s:3:"238";s:3:" qe";s:3:"239";s:3:" ta";s:3:"240";s:3:" ve";s:3:"241";s:3:"a p";s:3:"242";s:3:"cil";s:3:"243";s:3:"el ";s:3:"244";s:4:"erë";s:3:"245";s:3:"gji";s:3:"246";s:3:"hte";s:3:"247";s:3:"i t";s:3:"248";s:3:"jen";s:3:"249";s:3:"jit";s:3:"250";s:3:"k d";s:3:"251";s:4:"mën";s:3:"252";s:3:"n t";s:3:"253";s:3:"nyr";s:3:"254";s:3:"ori";s:3:"255";s:3:"pas";s:3:"256";s:3:"ra ";s:3:"257";s:3:"rie";s:3:"258";s:4:"rës";s:3:"259";s:3:"tor";s:3:"260";s:3:"uaj";s:3:"261";s:3:"yre";s:3:"262";s:4:"ëm ";s:3:"263";s:4:"ëny";s:3:"264";s:3:" ar";s:3:"265";s:3:" du";s:3:"266";s:3:" ga";s:3:"267";s:3:" je";s:3:"268";s:4:"dës";s:3:"269";s:3:"e e";s:3:"270";s:3:"e z";s:3:"271";s:3:"ha ";s:3:"272";s:3:"hme";s:3:"273";s:3:"ika";s:3:"274";s:3:"ini";s:3:"275";s:3:"ite";s:3:"276";s:3:"ith";s:3:"277";s:3:"koh";s:3:"278";s:3:"kra";s:3:"279";s:3:"ku ";s:3:"280";s:3:"lim";s:3:"281";s:3:"lis";s:3:"282";s:4:"qën";s:3:"283";s:4:"rën";s:3:"284";s:3:"s s";s:3:"285";s:3:"t d";s:3:"286";s:3:"t t";s:3:"287";s:3:"tir";s:3:"288";s:4:"tën";s:3:"289";s:3:"ver";s:3:"290";s:4:"ë j";s:3:"291";s:3:" ba";s:3:"292";s:3:" in";s:3:"293";s:3:" tr";s:3:"294";s:3:" zg";s:3:"295";s:3:"a a";s:3:"296";s:3:"a m";s:3:"297";s:3:"a t";s:3:"298";s:3:"abr";s:3:"299";}s:6:"arabic";a:300:{s:5:" ال";s:1:"0";s:6:"الع";s:1:"1";s:6:"لعر";s:1:"2";s:6:"عرا";s:1:"3";s:6:"راق";s:1:"4";s:5:" في";s:1:"5";s:5:"في ";s:1:"6";s:5:"ين ";s:1:"7";s:5:"ية ";s:1:"8";s:5:"ن ا";s:1:"9";s:6:"الم";s:2:"10";s:5:"ات ";s:2:"11";s:5:"من ";s:2:"12";s:5:"ي ا";s:2:"13";s:5:" من";s:2:"14";s:6:"الأ";s:2:"15";s:5:"ة ا";s:2:"16";s:5:"اق ";s:2:"17";s:5:" وا";s:2:"18";s:5:"اء ";s:2:"19";s:6:"الإ";s:2:"20";s:5:" أن";s:2:"21";s:6:"وال";s:2:"22";s:5:"ما ";s:2:"23";s:5:" عل";s:2:"24";s:5:"لى ";s:2:"25";s:5:"ت ا";s:2:"26";s:5:"ون ";s:2:"27";s:5:"هم ";s:2:"28";s:6:"اقي";s:2:"29";s:5:"ام ";s:2:"30";s:5:"ل ا";s:2:"31";s:5:"أن ";s:2:"32";s:5:"م ا";s:2:"33";s:6:"الت";s:2:"34";s:5:"لا ";s:2:"35";s:6:"الا";s:2:"36";s:5:"ان ";s:2:"37";s:5:"ها ";s:2:"38";s:5:"ال ";s:2:"39";s:5:"ة و";s:2:"40";s:5:"ا ا";s:2:"41";s:6:"رها";s:2:"42";s:6:"لام";s:2:"43";s:6:"يين";s:2:"44";s:5:" ول";s:2:"45";s:6:"لأم";s:2:"46";s:5:"نا ";s:2:"47";s:6:"على";s:2:"48";s:5:"ن ي";s:2:"49";s:6:"الب";s:2:"50";s:5:"اد ";s:2:"51";s:6:"الق";s:2:"52";s:5:"د ا";s:2:"53";s:5:"ذا ";s:2:"54";s:5:"ه ا";s:2:"55";s:5:" با";s:2:"56";s:6:"الد";s:2:"57";s:5:"ب ا";s:2:"58";s:6:"مري";s:2:"59";s:5:"لم ";s:2:"60";s:5:" إن";s:2:"61";s:5:" لل";s:2:"62";s:6:"سلا";s:2:"63";s:6:"أمر";s:2:"64";s:6:"ريك";s:2:"65";s:5:"مة ";s:2:"66";s:5:"ى ا";s:2:"67";s:5:"ا ي";s:2:"68";s:5:" عن";s:2:"69";s:5:" هذ";s:2:"70";s:5:"ء ا";s:2:"71";s:5:"ر ا";s:2:"72";s:6:"كان";s:2:"73";s:6:"قتل";s:2:"74";s:6:"إسل";s:2:"75";s:6:"الح";s:2:"76";s:5:"وا ";s:2:"77";s:5:" إل";s:2:"78";s:5:"ا أ";s:2:"79";s:6:"بال";s:2:"80";s:5:"ن م";s:2:"81";s:6:"الس";s:2:"82";s:5:"رة ";s:2:"83";s:6:"لإس";s:2:"84";s:5:"ن و";s:2:"85";s:6:"هاب";s:2:"86";s:5:"ي و";s:2:"87";s:5:"ير ";s:2:"88";s:5:" كا";s:2:"89";s:5:"لة ";s:2:"90";s:6:"يات";s:2:"91";s:5:" لا";s:2:"92";s:6:"انت";s:2:"93";s:5:"ن أ";s:2:"94";s:6:"يكي";s:2:"95";s:6:"الر";s:2:"96";s:6:"الو";s:2:"97";s:5:"ة ف";s:2:"98";s:5:"دة ";s:2:"99";s:6:"الج";s:3:"100";s:5:"قي ";s:3:"101";s:5:"وي ";s:3:"102";s:6:"الذ";s:3:"103";s:6:"الش";s:3:"104";s:6:"امي";s:3:"105";s:6:"اني";s:3:"106";s:5:"ذه ";s:3:"107";s:5:"عن ";s:3:"108";s:6:"لما";s:3:"109";s:6:"هذه";s:3:"110";s:5:"ول ";s:3:"111";s:5:"اف ";s:3:"112";s:6:"اوي";s:3:"113";s:6:"بري";s:3:"114";s:5:"ة ل";s:3:"115";s:5:" أم";s:3:"116";s:5:" لم";s:3:"117";s:5:" ما";s:3:"118";s:5:"يد ";s:3:"119";s:5:" أي";s:3:"120";s:6:"إره";s:3:"121";s:5:"ع ا";s:3:"122";s:6:"عمل";s:3:"123";s:6:"ولا";s:3:"124";s:6:"إلى";s:3:"125";s:6:"ابي";s:3:"126";s:5:"ن ف";s:3:"127";s:6:"ختط";s:3:"128";s:5:"لك ";s:3:"129";s:5:"نه ";s:3:"130";s:5:"ني ";s:3:"131";s:5:"إن ";s:3:"132";s:6:"دين";s:3:"133";s:5:"ف ا";s:3:"134";s:6:"لذي";s:3:"135";s:5:"ي أ";s:3:"136";s:5:"ي ب";s:3:"137";s:5:" وأ";s:3:"138";s:5:"ا ع";s:3:"139";s:6:"الخ";s:3:"140";s:5:"تل ";s:3:"141";s:5:"تي ";s:3:"142";s:5:"قد ";s:3:"143";s:6:"لدي";s:3:"144";s:5:" كل";s:3:"145";s:5:" مع";s:3:"146";s:5:"اب ";s:3:"147";s:6:"اخت";s:3:"148";s:5:"ار ";s:3:"149";s:6:"الن";s:3:"150";s:6:"علا";s:3:"151";s:5:"م و";s:3:"152";s:5:"مع ";s:3:"153";s:5:"س ا";s:3:"154";s:5:"كل ";s:3:"155";s:6:"لاء";s:3:"156";s:5:"ن ب";s:3:"157";s:5:"ن ت";s:3:"158";s:5:"ي م";s:3:"159";s:6:"عرب";s:3:"160";s:5:"م ب";s:3:"161";s:5:" وق";s:3:"162";s:5:" يق";s:3:"163";s:5:"ا ل";s:3:"164";s:5:"ا م";s:3:"165";s:6:"الف";s:3:"166";s:6:"تطا";s:3:"167";s:6:"داد";s:3:"168";s:6:"لمس";s:3:"169";s:5:"له ";s:3:"170";s:6:"هذا";s:3:"171";s:5:" مح";s:3:"172";s:6:"ؤلا";s:3:"173";s:5:"بي ";s:3:"174";s:5:"ة م";s:3:"175";s:5:"ن ل";s:3:"176";s:6:"هؤل";s:3:"177";s:5:"كن ";s:3:"178";s:6:"لإر";s:3:"179";s:6:"لتي";s:3:"180";s:5:" أو";s:3:"181";s:5:" ان";s:3:"182";s:5:" عم";s:3:"183";s:5:"ا ف";s:3:"184";s:5:"ة أ";s:3:"185";s:6:"طاف";s:3:"186";s:5:"عب ";s:3:"187";s:5:"ل م";s:3:"188";s:5:"ن ع";s:3:"189";s:5:"ور ";s:3:"190";s:5:"يا ";s:3:"191";s:5:" يس";s:3:"192";s:5:"ا ت";s:3:"193";s:5:"ة ب";s:3:"194";s:6:"راء";s:3:"195";s:6:"عال";s:3:"196";s:6:"قوا";s:3:"197";s:6:"قية";s:3:"198";s:6:"لعا";s:3:"199";s:5:"م ي";s:3:"200";s:5:"مي ";s:3:"201";s:6:"مية";s:3:"202";s:6:"نية";s:3:"203";s:5:"أي ";s:3:"204";s:6:"ابا";s:3:"205";s:6:"بغد";s:3:"206";s:5:"بل ";s:3:"207";s:5:"رب ";s:3:"208";s:6:"عما";s:3:"209";s:6:"غدا";s:3:"210";s:6:"مال";s:3:"211";s:6:"ملي";s:3:"212";s:5:"يس ";s:3:"213";s:5:" بأ";s:3:"214";s:5:" بع";s:3:"215";s:5:" بغ";s:3:"216";s:5:" وم";s:3:"217";s:6:"بات";s:3:"218";s:6:"بية";s:3:"219";s:6:"ذلك";s:3:"220";s:5:"عة ";s:3:"221";s:6:"قاو";s:3:"222";s:6:"قيي";s:3:"223";s:5:"كي ";s:3:"224";s:5:"م م";s:3:"225";s:5:"ي ع";s:3:"226";s:5:" عر";s:3:"227";s:5:" قا";s:3:"228";s:5:"ا و";s:3:"229";s:5:"رى ";s:3:"230";s:5:"ق ا";s:3:"231";s:6:"وات";s:3:"232";s:5:"وم ";s:3:"233";s:5:" هؤ";s:3:"234";s:5:"ا ب";s:3:"235";s:6:"دام";s:3:"236";s:5:"دي ";s:3:"237";s:6:"رات";s:3:"238";s:6:"شعب";s:3:"239";s:6:"لان";s:3:"240";s:6:"لشع";s:3:"241";s:6:"لقو";s:3:"242";s:6:"ليا";s:3:"243";s:5:"ن ه";s:3:"244";s:5:"ي ت";s:3:"245";s:5:"ي ي";s:3:"246";s:5:" وه";s:3:"247";s:5:" يح";s:3:"248";s:6:"جرا";s:3:"249";s:6:"جما";s:3:"250";s:6:"حمد";s:3:"251";s:5:"دم ";s:3:"252";s:5:"كم ";s:3:"253";s:6:"لاو";s:3:"254";s:6:"لره";s:3:"255";s:6:"ماع";s:3:"256";s:5:"ن ق";s:3:"257";s:5:"نة ";s:3:"258";s:5:"هي ";s:3:"259";s:5:" بل";s:3:"260";s:5:" به";s:3:"261";s:5:" له";s:3:"262";s:5:" وي";s:3:"263";s:5:"ا ك";s:3:"264";s:6:"اذا";s:3:"265";s:5:"اع ";s:3:"266";s:5:"ت م";s:3:"267";s:6:"تخا";s:3:"268";s:6:"خاب";s:3:"269";s:5:"ر م";s:3:"270";s:6:"لمت";s:3:"271";s:6:"مسل";s:3:"272";s:5:"ى أ";s:3:"273";s:6:"يست";s:3:"274";s:6:"يطا";s:3:"275";s:5:" لأ";s:3:"276";s:5:" لي";s:3:"277";s:6:"أمن";s:3:"278";s:6:"است";s:3:"279";s:6:"بعض";s:3:"280";s:5:"ة ت";s:3:"281";s:5:"ري ";s:3:"282";s:6:"صدا";s:3:"283";s:5:"ق و";s:3:"284";s:6:"قول";s:3:"285";s:5:"مد ";s:3:"286";s:6:"نتخ";s:3:"287";s:6:"نفس";s:3:"288";s:6:"نها";s:3:"289";s:6:"هنا";s:3:"290";s:6:"أعم";s:3:"291";s:6:"أنه";s:3:"292";s:6:"ائن";s:3:"293";s:6:"الآ";s:3:"294";s:6:"الك";s:3:"295";s:5:"حة ";s:3:"296";s:5:"د م";s:3:"297";s:5:"ر ع";s:3:"298";s:6:"ربي";s:3:"299";}s:5:"azeri";a:300:{s:4:"lər";s:1:"0";s:3:"in ";s:1:"1";s:4:"ın ";s:1:"2";s:3:"lar";s:1:"3";s:3:"da ";s:1:"4";s:3:"an ";s:1:"5";s:3:"ir ";s:1:"6";s:4:"də ";s:1:"7";s:3:"ki ";s:1:"8";s:3:" bi";s:1:"9";s:4:"ən ";s:2:"10";s:4:"əri";s:2:"11";s:4:"arı";s:2:"12";s:4:"ər ";s:2:"13";s:3:"dir";s:2:"14";s:3:"nda";s:2:"15";s:3:" ki";s:2:"16";s:3:"rin";s:2:"17";s:4:"nın";s:2:"18";s:4:"əsi";s:2:"19";s:3:"ini";s:2:"20";s:3:" ed";s:2:"21";s:3:" qa";s:2:"22";s:4:" tə";s:2:"23";s:3:" ba";s:2:"24";s:3:" ol";s:2:"25";s:4:"ası";s:2:"26";s:4:"ilə";s:2:"27";s:4:"rın";s:2:"28";s:3:" ya";s:2:"29";s:4:"anı";s:2:"30";s:4:" və";s:2:"31";s:4:"ndə";s:2:"32";s:3:"ni ";s:2:"33";s:3:"ara";s:2:"34";s:5:"ını";s:2:"35";s:4:"ınd";s:2:"36";s:3:" bu";s:2:"37";s:3:"si ";s:2:"38";s:3:"ib ";s:2:"39";s:3:"aq ";s:2:"40";s:4:"dən";s:2:"41";s:3:"iya";s:2:"42";s:4:"nə ";s:2:"43";s:4:"rə ";s:2:"44";s:3:"n b";s:2:"45";s:4:"sın";s:2:"46";s:4:"və ";s:2:"47";s:3:"iri";s:2:"48";s:4:"lə ";s:2:"49";s:3:"nin";s:2:"50";s:4:"əli";s:2:"51";s:3:" de";s:2:"52";s:4:" mü";s:2:"53";s:3:"bir";s:2:"54";s:3:"n s";s:2:"55";s:3:"ri ";s:2:"56";s:4:"ək ";s:2:"57";s:3:" az";s:2:"58";s:4:" sə";s:2:"59";s:3:"ar ";s:2:"60";s:3:"bil";s:2:"61";s:4:"zər";s:2:"62";s:3:"bu ";s:2:"63";s:3:"dan";s:2:"64";s:3:"edi";s:2:"65";s:3:"ind";s:2:"66";s:3:"man";s:2:"67";s:3:"un ";s:2:"68";s:5:"ərə";s:2:"69";s:3:" ha";s:2:"70";s:3:"lan";s:2:"71";s:4:"yyə";s:2:"72";s:3:"iyy";s:2:"73";s:3:" il";s:2:"74";s:3:" ne";s:2:"75";s:3:"r k";s:2:"76";s:4:"ə b";s:2:"77";s:3:" is";s:2:"78";s:3:"na ";s:2:"79";s:3:"nun";s:2:"80";s:4:"ır ";s:2:"81";s:3:" da";s:2:"82";s:4:" hə";s:2:"83";s:3:"a b";s:2:"84";s:4:"inə";s:2:"85";s:3:"sin";s:2:"86";s:3:"yan";s:2:"87";s:4:"ərb";s:2:"88";s:4:" də";s:2:"89";s:4:" mə";s:2:"90";s:4:" qə";s:2:"91";s:4:"dır";s:2:"92";s:3:"li ";s:2:"93";s:3:"ola";s:2:"94";s:3:"rba";s:2:"95";s:4:"azə";s:2:"96";s:3:"can";s:2:"97";s:4:"lı ";s:2:"98";s:3:"nla";s:2:"99";s:3:" et";s:3:"100";s:4:" gö";s:3:"101";s:4:"alı";s:3:"102";s:3:"ayc";s:3:"103";s:3:"bay";s:3:"104";s:3:"eft";s:3:"105";s:3:"ist";s:3:"106";s:3:"n i";s:3:"107";s:3:"nef";s:3:"108";s:4:"tlə";s:3:"109";s:3:"yca";s:3:"110";s:4:"yət";s:3:"111";s:5:"əcə";s:3:"112";s:3:" la";s:3:"113";s:3:"ild";s:3:"114";s:4:"nı ";s:3:"115";s:3:"tin";s:3:"116";s:3:"ldi";s:3:"117";s:3:"lik";s:3:"118";s:3:"n h";s:3:"119";s:3:"n m";s:3:"120";s:3:"oyu";s:3:"121";s:3:"raq";s:3:"122";s:3:"ya ";s:3:"123";s:4:"əti";s:3:"124";s:3:" ar";s:3:"125";s:3:"ada";s:3:"126";s:4:"edə";s:3:"127";s:3:"mas";s:3:"128";s:4:"sı ";s:3:"129";s:4:"ına";s:3:"130";s:4:"ə d";s:3:"131";s:5:"ələ";s:3:"132";s:4:"ayı";s:3:"133";s:3:"iyi";s:3:"134";s:3:"lma";s:3:"135";s:4:"mək";s:3:"136";s:3:"n d";s:3:"137";s:3:"ti ";s:3:"138";s:3:"yin";s:3:"139";s:3:"yun";s:3:"140";s:4:"ət ";s:3:"141";s:4:"azı";s:3:"142";s:3:"ft ";s:3:"143";s:3:"i t";s:3:"144";s:3:"lli";s:3:"145";s:3:"n a";s:3:"146";s:3:"ra ";s:3:"147";s:4:" cə";s:3:"148";s:4:" gə";s:3:"149";s:3:" ko";s:3:"150";s:4:" nə";s:3:"151";s:3:" oy";s:3:"152";s:3:"a d";s:3:"153";s:3:"ana";s:3:"154";s:4:"cək";s:3:"155";s:3:"eyi";s:3:"156";s:3:"ilm";s:3:"157";s:3:"irl";s:3:"158";s:3:"lay";s:3:"159";s:3:"liy";s:3:"160";s:3:"lub";s:3:"161";s:4:"n ə";s:3:"162";s:3:"ril";s:3:"163";s:4:"rlə";s:3:"164";s:3:"unu";s:3:"165";s:3:"ver";s:3:"166";s:4:"ün ";s:3:"167";s:4:"ə o";s:3:"168";s:4:"əni";s:3:"169";s:3:" he";s:3:"170";s:3:" ma";s:3:"171";s:3:" on";s:3:"172";s:3:" pa";s:3:"173";s:3:"ala";s:3:"174";s:3:"dey";s:3:"175";s:3:"i m";s:3:"176";s:3:"ima";s:3:"177";s:4:"lmə";s:3:"178";s:4:"mət";s:3:"179";s:3:"par";s:3:"180";s:4:"yə ";s:3:"181";s:4:"ətl";s:3:"182";s:3:" al";s:3:"183";s:3:" mi";s:3:"184";s:3:" sa";s:3:"185";s:4:" əl";s:3:"186";s:4:"adı";s:3:"187";s:4:"akı";s:3:"188";s:3:"and";s:3:"189";s:3:"ard";s:3:"190";s:3:"art";s:3:"191";s:3:"ayi";s:3:"192";s:3:"i a";s:3:"193";s:3:"i q";s:3:"194";s:3:"i y";s:3:"195";s:3:"ili";s:3:"196";s:3:"ill";s:3:"197";s:4:"isə";s:3:"198";s:3:"n o";s:3:"199";s:3:"n q";s:3:"200";s:3:"olu";s:3:"201";s:3:"rla";s:3:"202";s:4:"stə";s:3:"203";s:4:"sə ";s:3:"204";s:3:"tan";s:3:"205";s:3:"tel";s:3:"206";s:3:"yar";s:3:"207";s:5:"ədə";s:3:"208";s:3:" me";s:3:"209";s:4:" rə";s:3:"210";s:3:" ve";s:3:"211";s:3:" ye";s:3:"212";s:3:"a k";s:3:"213";s:3:"at ";s:3:"214";s:4:"baş";s:3:"215";s:3:"diy";s:3:"216";s:3:"ent";s:3:"217";s:3:"eti";s:3:"218";s:4:"həs";s:3:"219";s:3:"i i";s:3:"220";s:3:"ik ";s:3:"221";s:3:"la ";s:3:"222";s:4:"miş";s:3:"223";s:3:"n n";s:3:"224";s:3:"nu ";s:3:"225";s:3:"qar";s:3:"226";s:3:"ran";s:3:"227";s:4:"tər";s:3:"228";s:3:"xan";s:3:"229";s:4:"ə a";s:3:"230";s:4:"ə g";s:3:"231";s:4:"ə t";s:3:"232";s:4:" dü";s:3:"233";s:3:"ama";s:3:"234";s:3:"b k";s:3:"235";s:3:"dil";s:3:"236";s:3:"era";s:3:"237";s:3:"etm";s:3:"238";s:3:"i b";s:3:"239";s:3:"kil";s:3:"240";s:3:"mil";s:3:"241";s:3:"n r";s:3:"242";s:3:"qla";s:3:"243";s:3:"r s";s:3:"244";s:3:"ras";s:3:"245";s:3:"siy";s:3:"246";s:3:"son";s:3:"247";s:3:"tim";s:3:"248";s:3:"yer";s:3:"249";s:4:"ə k";s:3:"250";s:4:" gü";s:3:"251";s:3:" so";s:3:"252";s:4:" sö";s:3:"253";s:3:" te";s:3:"254";s:3:" xa";s:3:"255";s:3:"ai ";s:3:"256";s:3:"bar";s:3:"257";s:3:"cti";s:3:"258";s:3:"di ";s:3:"259";s:3:"eri";s:3:"260";s:4:"gör";s:3:"261";s:4:"gün";s:3:"262";s:4:"gəl";s:3:"263";s:4:"hbə";s:3:"264";s:4:"ihə";s:3:"265";s:3:"iki";s:3:"266";s:3:"isi";s:3:"267";s:3:"lin";s:3:"268";s:3:"mai";s:3:"269";s:3:"maq";s:3:"270";s:3:"n k";s:3:"271";s:3:"n t";s:3:"272";s:3:"n v";s:3:"273";s:3:"onu";s:3:"274";s:3:"qan";s:3:"275";s:4:"qəz";s:3:"276";s:4:"tə ";s:3:"277";s:3:"xal";s:3:"278";s:3:"yib";s:3:"279";s:3:"yih";s:3:"280";s:3:"zet";s:3:"281";s:4:"zır";s:3:"282";s:4:"ıb ";s:3:"283";s:4:"ə m";s:3:"284";s:4:"əze";s:3:"285";s:3:" br";s:3:"286";s:3:" in";s:3:"287";s:4:" i̇";s:3:"288";s:3:" pr";s:3:"289";s:3:" ta";s:3:"290";s:3:" to";s:3:"291";s:5:" üç";s:3:"292";s:3:"a o";s:3:"293";s:3:"ali";s:3:"294";s:3:"ani";s:3:"295";s:3:"anl";s:3:"296";s:3:"aql";s:3:"297";s:3:"azi";s:3:"298";s:3:"bri";s:3:"299";}s:7:"bengali";a:300:{s:7:"ার ";s:1:"0";s:7:"য় ";s:1:"1";s:9:"েয়";s:1:"2";s:9:"য়া";s:1:"3";s:7:" কর";s:1:"4";s:7:"েত ";s:1:"5";s:7:" কা";s:1:"6";s:7:" পা";s:1:"7";s:7:" তা";s:1:"8";s:7:"না ";s:1:"9";s:9:"ায়";s:2:"10";s:7:"ের ";s:2:"11";s:9:"য়ে";s:2:"12";s:7:" বা";s:2:"13";s:7:"েব ";s:2:"14";s:7:" যা";s:2:"15";s:7:" হে";s:2:"16";s:7:" সা";s:2:"17";s:7:"ান ";s:2:"18";s:7:"েছ ";s:2:"19";s:7:" িন";s:2:"20";s:7:"েল ";s:2:"21";s:7:" িদ";s:2:"22";s:7:" না";s:2:"23";s:7:" িব";s:2:"24";s:7:"েক ";s:2:"25";s:7:"লা ";s:2:"26";s:7:"তা ";s:2:"27";s:7:" বઘ";s:2:"28";s:7:" িক";s:2:"29";s:9:"করে";s:2:"30";s:7:" পચ";s:2:"31";s:9:"াের";s:2:"32";s:9:"িনে";s:2:"33";s:7:"রা ";s:2:"34";s:7:" োব";s:2:"35";s:7:"কা ";s:2:"36";s:7:" কে";s:2:"37";s:7:" টা";s:2:"38";s:7:"র ক";s:2:"39";s:9:"েলা";s:2:"40";s:7:" োক";s:2:"41";s:7:" মা";s:2:"42";s:7:" োদ";s:2:"43";s:7:" োম";s:2:"44";s:7:"দর ";s:2:"45";s:7:"়া ";s:2:"46";s:9:"িদে";s:2:"47";s:9:"াকা";s:2:"48";s:9:"়েছ";s:2:"49";s:9:"েদর";s:2:"50";s:7:" আে";s:2:"51";s:5:" ও ";s:2:"52";s:7:"াল ";s:2:"53";s:7:"িট ";s:2:"54";s:7:" মু";s:2:"55";s:9:"কের";s:2:"56";s:9:"হয়";s:2:"57";s:9:"করা";s:2:"58";s:7:"পর ";s:2:"59";s:9:"পাে";s:2:"60";s:7:" এক";s:2:"61";s:7:" পদ";s:2:"62";s:9:"টাক";s:2:"63";s:7:"ড় ";s:2:"64";s:9:"কান";s:2:"65";s:7:"টা ";s:2:"66";s:9:"দગা";s:2:"67";s:9:"পদગ";s:2:"68";s:9:"াড়";s:2:"69";s:9:"োকা";s:2:"70";s:9:"ওয়";s:2:"71";s:9:"কাপ";s:2:"72";s:9:"হেয";s:2:"73";s:9:"েনর";s:2:"74";s:7:" হয";s:2:"75";s:9:"দেয";s:2:"76";s:7:"নর ";s:2:"77";s:9:"ানা";s:2:"78";s:9:"ােল";s:2:"79";s:7:" আর";s:2:"80";s:5:" ় ";s:2:"81";s:9:"বઘব";s:2:"82";s:9:"িয়";s:2:"83";s:7:" দা";s:2:"84";s:7:" সম";s:2:"85";s:9:"কার";s:2:"86";s:9:"হার";s:2:"87";s:7:"াই ";s:2:"88";s:9:"ড়া";s:2:"89";s:9:"িবি";s:2:"90";s:7:" রা";s:2:"91";s:7:" লা";s:2:"92";s:9:"নার";s:2:"93";s:9:"বহা";s:2:"94";s:7:"বা ";s:2:"95";s:9:"যায";s:2:"96";s:7:"েন ";s:2:"97";s:9:"ઘবহ";s:2:"98";s:7:" ভা";s:2:"99";s:7:" সে";s:3:"100";s:7:" োয";s:3:"101";s:7:"রর ";s:3:"102";s:9:"়ার";s:3:"103";s:9:"়াল";s:3:"104";s:7:"ગা ";s:3:"105";s:9:"থেক";s:3:"106";s:9:"ভাে";s:3:"107";s:7:"়ে ";s:3:"108";s:9:"েরর";s:3:"109";s:7:" ধর";s:3:"110";s:7:" হা";s:3:"111";s:7:"নઘ ";s:3:"112";s:9:"রেন";s:3:"113";s:9:"ােব";s:3:"114";s:9:"িড়";s:3:"115";s:7:"ির ";s:3:"116";s:7:" োথ";s:3:"117";s:9:"তার";s:3:"118";s:9:"বিভ";s:3:"119";s:9:"রেত";s:3:"120";s:9:"সাে";s:3:"121";s:9:"াকে";s:3:"122";s:9:"ােত";s:3:"123";s:9:"িভਭ";s:3:"124";s:7:"ে ব";s:3:"125";s:9:"োথে";s:3:"126";s:7:" োপ";s:3:"127";s:7:" োস";s:3:"128";s:9:"বার";s:3:"129";s:7:"ভਭ ";s:3:"130";s:7:"রন ";s:3:"131";s:7:"াম ";s:3:"132";s:7:" এখ";s:3:"133";s:7:"আর ";s:3:"134";s:9:"কাে";s:3:"135";s:7:"দন ";s:3:"136";s:9:"সাজ";s:3:"137";s:9:"ােক";s:3:"138";s:9:"ােন";s:3:"139";s:9:"েনা";s:3:"140";s:7:" ঘে";s:3:"141";s:7:" তে";s:3:"142";s:7:" রে";s:3:"143";s:9:"তেব";s:3:"144";s:7:"বন ";s:3:"145";s:9:"বઘা";s:3:"146";s:9:"েড়";s:3:"147";s:9:"েবন";s:3:"148";s:7:" খু";s:3:"149";s:7:" চা";s:3:"150";s:7:" সু";s:3:"151";s:7:"কে ";s:3:"152";s:9:"ধরে";s:3:"153";s:7:"র ো";s:3:"154";s:7:"় ি";s:3:"155";s:7:"া ি";s:3:"156";s:9:"ােথ";s:3:"157";s:9:"াਠা";s:3:"158";s:7:"িদ ";s:3:"159";s:7:"িন ";s:3:"160";s:7:" অন";s:3:"161";s:7:" আপ";s:3:"162";s:7:" আম";s:3:"163";s:7:" থা";s:3:"164";s:7:" বચ";s:3:"165";s:7:" োফ";s:3:"166";s:7:" ৌত";s:3:"167";s:9:"ঘের";s:3:"168";s:7:"তে ";s:3:"169";s:9:"ময়";s:3:"170";s:9:"যাਠ";s:3:"171";s:7:"র স";s:3:"172";s:9:"রাখ";s:3:"173";s:7:"া ব";s:3:"174";s:7:"া ো";s:3:"175";s:9:"ালা";s:3:"176";s:7:"িক ";s:3:"177";s:7:"িশ ";s:3:"178";s:7:"েখ ";s:3:"179";s:7:" এর";s:3:"180";s:7:" চઓ";s:3:"181";s:7:" িড";s:3:"182";s:7:"খন ";s:3:"183";s:9:"ড়ে";s:3:"184";s:7:"র ব";s:3:"185";s:7:"়র ";s:3:"186";s:9:"াইে";s:3:"187";s:9:"ােদ";s:3:"188";s:9:"িদন";s:3:"189";s:9:"েরন";s:3:"190";s:7:" তੴ";s:3:"191";s:9:"ছাড";s:3:"192";s:9:"জনઘ";s:3:"193";s:9:"তাই";s:3:"194";s:7:"মা ";s:3:"195";s:9:"মাে";s:3:"196";s:9:"লার";s:3:"197";s:7:"াজ ";s:3:"198";s:9:"াতা";s:3:"199";s:9:"ামা";s:3:"200";s:9:"ਊেল";s:3:"201";s:9:"ગার";s:3:"202";s:7:" সব";s:3:"203";s:9:"আপন";s:3:"204";s:9:"একট";s:3:"205";s:9:"কাি";s:3:"206";s:9:"জাই";s:3:"207";s:7:"টর ";s:3:"208";s:9:"ডজা";s:3:"209";s:9:"দেখ";s:3:"210";s:9:"পনা";s:3:"211";s:7:"রও ";s:3:"212";s:7:"লে ";s:3:"213";s:9:"হেব";s:3:"214";s:9:"াজা";s:3:"215";s:9:"ািট";s:3:"216";s:9:"িডজ";s:3:"217";s:7:"েথ ";s:3:"218";s:7:" এব";s:3:"219";s:7:" জন";s:3:"220";s:7:" জা";s:3:"221";s:9:"আমা";s:3:"222";s:9:"গেল";s:3:"223";s:9:"জান";s:3:"224";s:9:"নেত";s:3:"225";s:9:"বিশ";s:3:"226";s:9:"মুে";s:3:"227";s:9:"মেয";s:3:"228";s:7:"র প";s:3:"229";s:7:"সে ";s:3:"230";s:9:"হেল";s:3:"231";s:7:"় ো";s:3:"232";s:7:"া হ";s:3:"233";s:9:"াওয";s:3:"234";s:9:"োমক";s:3:"235";s:9:"ઘাি";s:3:"236";s:7:" অে";s:3:"237";s:5:" ট ";s:3:"238";s:7:" োগ";s:3:"239";s:7:" োন";s:3:"240";s:7:"জর ";s:3:"241";s:9:"তির";s:3:"242";s:9:"দাম";s:3:"243";s:9:"পড়";s:3:"244";s:9:"পার";s:3:"245";s:9:"বাঘ";s:3:"246";s:9:"মকা";s:3:"247";s:9:"মাম";s:3:"248";s:9:"য়র";s:3:"249";s:9:"যাে";s:3:"250";s:7:"র ম";s:3:"251";s:7:"রে ";s:3:"252";s:7:"লর ";s:3:"253";s:7:"া ক";s:3:"254";s:7:"াগ ";s:3:"255";s:9:"াবা";s:3:"256";s:9:"ারা";s:3:"257";s:9:"ািন";s:3:"258";s:7:"ে গ";s:3:"259";s:7:"েগ ";s:3:"260";s:9:"েলর";s:3:"261";s:9:"োদখ";s:3:"262";s:9:"োবি";s:3:"263";s:7:"ઓল ";s:3:"264";s:7:" দে";s:3:"265";s:7:" পু";s:3:"266";s:7:" বে";s:3:"267";s:9:"অেন";s:3:"268";s:9:"এখন";s:3:"269";s:9:"কছু";s:3:"270";s:9:"কাল";s:3:"271";s:9:"গেয";s:3:"272";s:7:"ছন ";s:3:"273";s:7:"ত প";s:3:"274";s:9:"নেয";s:3:"275";s:9:"পাি";s:3:"276";s:7:"মন ";s:3:"277";s:7:"র আ";s:3:"278";s:9:"রার";s:3:"279";s:7:"াও ";s:3:"280";s:7:"াপ ";s:3:"281";s:9:"িকছ";s:3:"282";s:9:"িগে";s:3:"283";s:9:"েছন";s:3:"284";s:9:"েজর";s:3:"285";s:9:"োমা";s:3:"286";s:9:"োমে";s:3:"287";s:9:"ৌতি";s:3:"288";s:9:"ઘাে";s:3:"289";s:3:" ' ";s:3:"290";s:7:" এছ";s:3:"291";s:7:" ছা";s:3:"292";s:7:" বল";s:3:"293";s:7:" যি";s:3:"294";s:7:" শি";s:3:"295";s:7:" িম";s:3:"296";s:7:" োল";s:3:"297";s:9:"এছা";s:3:"298";s:7:"খা ";s:3:"299";}s:9:"bulgarian";a:300:{s:5:"на ";s:1:"0";s:5:" на";s:1:"1";s:5:"то ";s:1:"2";s:5:" пр";s:1:"3";s:5:" за";s:1:"4";s:5:"та ";s:1:"5";s:5:" по";s:1:"6";s:6:"ите";s:1:"7";s:5:"те ";s:1:"8";s:5:"а п";s:1:"9";s:5:"а с";s:2:"10";s:5:" от";s:2:"11";s:5:"за ";s:2:"12";s:6:"ата";s:2:"13";s:5:"ия ";s:2:"14";s:4:" в ";s:2:"15";s:5:"е н";s:2:"16";s:5:" да";s:2:"17";s:5:"а н";s:2:"18";s:5:" се";s:2:"19";s:5:" ко";s:2:"20";s:5:"да ";s:2:"21";s:5:"от ";s:2:"22";s:6:"ани";s:2:"23";s:6:"пре";s:2:"24";s:5:"не ";s:2:"25";s:6:"ени";s:2:"26";s:5:"о н";s:2:"27";s:5:"ни ";s:2:"28";s:5:"се ";s:2:"29";s:4:" и ";s:2:"30";s:5:"но ";s:2:"31";s:6:"ане";s:2:"32";s:6:"ето";s:2:"33";s:5:"а в";s:2:"34";s:5:"ва ";s:2:"35";s:6:"ван";s:2:"36";s:5:"е п";s:2:"37";s:5:"а о";s:2:"38";s:6:"ото";s:2:"39";s:6:"ран";s:2:"40";s:5:"ат ";s:2:"41";s:6:"ред";s:2:"42";s:5:" не";s:2:"43";s:5:"а д";s:2:"44";s:5:"и п";s:2:"45";s:5:" до";s:2:"46";s:6:"про";s:2:"47";s:5:" съ";s:2:"48";s:5:"ли ";s:2:"49";s:6:"при";s:2:"50";s:6:"ния";s:2:"51";s:6:"ски";s:2:"52";s:6:"тел";s:2:"53";s:5:"а и";s:2:"54";s:5:"по ";s:2:"55";s:5:"ри ";s:2:"56";s:4:" е ";s:2:"57";s:5:" ка";s:2:"58";s:6:"ира";s:2:"59";s:6:"кат";s:2:"60";s:6:"ние";s:2:"61";s:6:"нит";s:2:"62";s:5:"е з";s:2:"63";s:5:"и с";s:2:"64";s:5:"о с";s:2:"65";s:6:"ост";s:2:"66";s:5:"че ";s:2:"67";s:5:" ра";s:2:"68";s:6:"ист";s:2:"69";s:5:"о п";s:2:"70";s:5:" из";s:2:"71";s:5:" са";s:2:"72";s:5:"е д";s:2:"73";s:6:"ини";s:2:"74";s:5:"ки ";s:2:"75";s:6:"мин";s:2:"76";s:5:" ми";s:2:"77";s:5:"а б";s:2:"78";s:6:"ава";s:2:"79";s:5:"е в";s:2:"80";s:5:"ие ";s:2:"81";s:6:"пол";s:2:"82";s:6:"ств";s:2:"83";s:5:"т н";s:2:"84";s:5:" въ";s:2:"85";s:5:" ст";s:2:"86";s:5:" то";s:2:"87";s:6:"аза";s:2:"88";s:5:"е о";s:2:"89";s:5:"ов ";s:2:"90";s:5:"ст ";s:2:"91";s:5:"ът ";s:2:"92";s:5:"и н";s:2:"93";s:6:"ият";s:2:"94";s:6:"нат";s:2:"95";s:5:"ра ";s:2:"96";s:5:" бъ";s:2:"97";s:5:" че";s:2:"98";s:6:"алн";s:2:"99";s:5:"е с";s:3:"100";s:5:"ен ";s:3:"101";s:6:"ест";s:3:"102";s:5:"и д";s:3:"103";s:6:"лен";s:3:"104";s:6:"нис";s:3:"105";s:5:"о о";s:3:"106";s:6:"ови";s:3:"107";s:5:" об";s:3:"108";s:5:" сл";s:3:"109";s:5:"а р";s:3:"110";s:6:"ато";s:3:"111";s:6:"кон";s:3:"112";s:6:"нос";s:3:"113";s:6:"ров";s:3:"114";s:5:"ще ";s:3:"115";s:5:" ре";s:3:"116";s:4:" с ";s:3:"117";s:5:" сп";s:3:"118";s:6:"ват";s:3:"119";s:6:"еше";s:3:"120";s:5:"и в";s:3:"121";s:6:"иет";s:3:"122";s:5:"о в";s:3:"123";s:6:"ове";s:3:"124";s:6:"ста";s:3:"125";s:5:"а к";s:3:"126";s:5:"а т";s:3:"127";s:6:"дат";s:3:"128";s:6:"ент";s:3:"129";s:5:"ка ";s:3:"130";s:6:"лед";s:3:"131";s:6:"нет";s:3:"132";s:6:"ори";s:3:"133";s:6:"стр";s:3:"134";s:6:"стъ";s:3:"135";s:5:"ти ";s:3:"136";s:6:"тър";s:3:"137";s:5:" те";s:3:"138";s:5:"а з";s:3:"139";s:5:"а м";s:3:"140";s:5:"ад ";s:3:"141";s:6:"ана";s:3:"142";s:6:"ено";s:3:"143";s:5:"и о";s:3:"144";s:6:"ина";s:3:"145";s:6:"ити";s:3:"146";s:5:"ма ";s:3:"147";s:6:"ска";s:3:"148";s:6:"сле";s:3:"149";s:6:"тво";s:3:"150";s:6:"тер";s:3:"151";s:6:"ция";s:3:"152";s:5:"ят ";s:3:"153";s:5:" бе";s:3:"154";s:5:" де";s:3:"155";s:5:" па";s:3:"156";s:6:"ате";s:3:"157";s:6:"вен";s:3:"158";s:5:"ви ";s:3:"159";s:6:"вит";s:3:"160";s:5:"и з";s:3:"161";s:5:"и и";s:3:"162";s:6:"нар";s:3:"163";s:6:"нов";s:3:"164";s:6:"ова";s:3:"165";s:6:"пов";s:3:"166";s:6:"рез";s:3:"167";s:6:"рит";s:3:"168";s:5:"са ";s:3:"169";s:6:"ята";s:3:"170";s:5:" го";s:3:"171";s:5:" ще";s:3:"172";s:6:"али";s:3:"173";s:5:"в п";s:3:"174";s:6:"гра";s:3:"175";s:5:"е и";s:3:"176";s:6:"еди";s:3:"177";s:6:"ели";s:3:"178";s:6:"или";s:3:"179";s:6:"каз";s:3:"180";s:6:"кит";s:3:"181";s:6:"лно";s:3:"182";s:6:"мен";s:3:"183";s:6:"оли";s:3:"184";s:6:"раз";s:3:"185";s:5:" ве";s:3:"186";s:5:" гр";s:3:"187";s:5:" им";s:3:"188";s:5:" ме";s:3:"189";s:5:" пъ";s:3:"190";s:6:"ави";s:3:"191";s:6:"ако";s:3:"192";s:6:"ача";s:3:"193";s:6:"вин";s:3:"194";s:5:"во ";s:3:"195";s:6:"гов";s:3:"196";s:6:"дан";s:3:"197";s:5:"ди ";s:3:"198";s:5:"до ";s:3:"199";s:5:"ед ";s:3:"200";s:6:"ери";s:3:"201";s:6:"еро";s:3:"202";s:6:"жда";s:3:"203";s:6:"ито";s:3:"204";s:6:"ков";s:3:"205";s:6:"кол";s:3:"206";s:6:"лни";s:3:"207";s:6:"мер";s:3:"208";s:6:"нач";s:3:"209";s:5:"о з";s:3:"210";s:6:"ола";s:3:"211";s:5:"он ";s:3:"212";s:6:"она";s:3:"213";s:6:"пра";s:3:"214";s:6:"рав";s:3:"215";s:6:"рем";s:3:"216";s:6:"сия";s:3:"217";s:6:"сти";s:3:"218";s:5:"т п";s:3:"219";s:6:"тан";s:3:"220";s:5:"ха ";s:3:"221";s:5:"ше ";s:3:"222";s:6:"шен";s:3:"223";s:6:"ълг";s:3:"224";s:5:" ба";s:3:"225";s:5:" си";s:3:"226";s:6:"аро";s:3:"227";s:6:"бъл";s:3:"228";s:5:"в р";s:3:"229";s:6:"гар";s:3:"230";s:5:"е е";s:3:"231";s:6:"елн";s:3:"232";s:6:"еме";s:3:"233";s:6:"ико";s:3:"234";s:6:"има";s:3:"235";s:5:"ко ";s:3:"236";s:6:"кои";s:3:"237";s:5:"ла ";s:3:"238";s:6:"лга";s:3:"239";s:5:"о д";s:3:"240";s:6:"ози";s:3:"241";s:6:"оит";s:3:"242";s:6:"под";s:3:"243";s:6:"рес";s:3:"244";s:6:"рие";s:3:"245";s:6:"сто";s:3:"246";s:5:"т к";s:3:"247";s:5:"т м";s:3:"248";s:5:"т с";s:3:"249";s:6:"уст";s:3:"250";s:5:" би";s:3:"251";s:5:" дв";s:3:"252";s:5:" дъ";s:3:"253";s:5:" ма";s:3:"254";s:5:" мо";s:3:"255";s:5:" ни";s:3:"256";s:5:" ос";s:3:"257";s:6:"ала";s:3:"258";s:6:"анс";s:3:"259";s:6:"ара";s:3:"260";s:6:"ати";s:3:"261";s:6:"аци";s:3:"262";s:6:"беш";s:3:"263";s:6:"вър";s:3:"264";s:5:"е р";s:3:"265";s:6:"едв";s:3:"266";s:6:"ема";s:3:"267";s:6:"жав";s:3:"268";s:5:"и к";s:3:"269";s:6:"иал";s:3:"270";s:6:"ица";s:3:"271";s:6:"иче";s:3:"272";s:6:"кия";s:3:"273";s:6:"лит";s:3:"274";s:5:"о б";s:3:"275";s:6:"ово";s:3:"276";s:6:"оди";s:3:"277";s:6:"ока";s:3:"278";s:6:"пос";s:3:"279";s:6:"род";s:3:"280";s:6:"сед";s:3:"281";s:6:"слу";s:3:"282";s:5:"т и";s:3:"283";s:6:"тов";s:3:"284";s:6:"ува";s:3:"285";s:6:"циа";s:3:"286";s:6:"чес";s:3:"287";s:5:"я з";s:3:"288";s:5:" во";s:3:"289";s:5:" ил";s:3:"290";s:5:" ск";s:3:"291";s:5:" тр";s:3:"292";s:5:" це";s:3:"293";s:6:"ами";s:3:"294";s:6:"ари";s:3:"295";s:6:"бат";s:3:"296";s:5:"би ";s:3:"297";s:6:"бра";s:3:"298";s:6:"бъд";s:3:"299";}s:7:"cebuano";a:300:{s:3:"ng ";s:1:"0";s:3:"sa ";s:1:"1";s:3:" sa";s:1:"2";s:3:"ang";s:1:"3";s:3:"ga ";s:1:"4";s:3:"nga";s:1:"5";s:3:" ka";s:1:"6";s:3:" ng";s:1:"7";s:3:"an ";s:1:"8";s:3:" an";s:1:"9";s:3:" na";s:2:"10";s:3:" ma";s:2:"11";s:3:" ni";s:2:"12";s:3:"a s";s:2:"13";s:3:"a n";s:2:"14";s:3:"on ";s:2:"15";s:3:" pa";s:2:"16";s:3:" si";s:2:"17";s:3:"a k";s:2:"18";s:3:"a m";s:2:"19";s:3:" ba";s:2:"20";s:3:"ong";s:2:"21";s:3:"a i";s:2:"22";s:3:"ila";s:2:"23";s:3:" mg";s:2:"24";s:3:"mga";s:2:"25";s:3:"a p";s:2:"26";s:3:"iya";s:2:"27";s:3:"a a";s:2:"28";s:3:"ay ";s:2:"29";s:3:"ka ";s:2:"30";s:3:"ala";s:2:"31";s:3:"ing";s:2:"32";s:3:"g m";s:2:"33";s:3:"n s";s:2:"34";s:3:"g n";s:2:"35";s:3:"lan";s:2:"36";s:3:" gi";s:2:"37";s:3:"na ";s:2:"38";s:3:"ni ";s:2:"39";s:3:"o s";s:2:"40";s:3:"g p";s:2:"41";s:3:"n n";s:2:"42";s:3:" da";s:2:"43";s:3:"ag ";s:2:"44";s:3:"pag";s:2:"45";s:3:"g s";s:2:"46";s:3:"yan";s:2:"47";s:3:"ayo";s:2:"48";s:3:"o n";s:2:"49";s:3:"si ";s:2:"50";s:3:" mo";s:2:"51";s:3:"a b";s:2:"52";s:3:"g a";s:2:"53";s:3:"ail";s:2:"54";s:3:"g b";s:2:"55";s:3:"han";s:2:"56";s:3:"a d";s:2:"57";s:3:"asu";s:2:"58";s:3:"nag";s:2:"59";s:3:"ya ";s:2:"60";s:3:"man";s:2:"61";s:3:"ne ";s:2:"62";s:3:"pan";s:2:"63";s:3:"kon";s:2:"64";s:3:" il";s:2:"65";s:3:" la";s:2:"66";s:3:"aka";s:2:"67";s:3:"ako";s:2:"68";s:3:"ana";s:2:"69";s:3:"bas";s:2:"70";s:3:"ko ";s:2:"71";s:3:"od ";s:2:"72";s:3:"yo ";s:2:"73";s:3:" di";s:2:"74";s:3:" ko";s:2:"75";s:3:" ug";s:2:"76";s:3:"a u";s:2:"77";s:3:"g k";s:2:"78";s:3:"kan";s:2:"79";s:3:"la ";s:2:"80";s:3:"len";s:2:"81";s:3:"sur";s:2:"82";s:3:"ug ";s:2:"83";s:3:" ai";s:2:"84";s:3:"apa";s:2:"85";s:3:"aw ";s:2:"86";s:3:"d s";s:2:"87";s:3:"g d";s:2:"88";s:3:"g g";s:2:"89";s:3:"ile";s:2:"90";s:3:"nin";s:2:"91";s:3:" iy";s:2:"92";s:3:" su";s:2:"93";s:3:"ene";s:2:"94";s:3:"og ";s:2:"95";s:3:"ot ";s:2:"96";s:3:"aba";s:2:"97";s:3:"aha";s:2:"98";s:3:"as ";s:2:"99";s:3:"imo";s:3:"100";s:3:" ki";s:3:"101";s:3:"a t";s:3:"102";s:3:"aga";s:3:"103";s:3:"ban";s:3:"104";s:3:"ero";s:3:"105";s:3:"nan";s:3:"106";s:3:"o k";s:3:"107";s:3:"ran";s:3:"108";s:3:"ron";s:3:"109";s:3:"sil";s:3:"110";s:3:"una";s:3:"111";s:3:"usa";s:3:"112";s:3:" us";s:3:"113";s:3:"a g";s:3:"114";s:3:"ahi";s:3:"115";s:3:"ani";s:3:"116";s:3:"er ";s:3:"117";s:3:"ha ";s:3:"118";s:3:"i a";s:3:"119";s:3:"rer";s:3:"120";s:3:"yon";s:3:"121";s:3:" pu";s:3:"122";s:3:"ini";s:3:"123";s:3:"nak";s:3:"124";s:3:"ro ";s:3:"125";s:3:"to ";s:3:"126";s:3:"ure";s:3:"127";s:3:" ed";s:3:"128";s:3:" og";s:3:"129";s:3:" wa";s:3:"130";s:3:"ili";s:3:"131";s:3:"mo ";s:3:"132";s:3:"n a";s:3:"133";s:3:"nd ";s:3:"134";s:3:"o a";s:3:"135";s:3:" ad";s:3:"136";s:3:" du";s:3:"137";s:3:" pr";s:3:"138";s:3:"aro";s:3:"139";s:3:"i s";s:3:"140";s:3:"ma ";s:3:"141";s:3:"n m";s:3:"142";s:3:"ulo";s:3:"143";s:3:"und";s:3:"144";s:3:" ta";s:3:"145";s:3:"ara";s:3:"146";s:3:"asa";s:3:"147";s:3:"ato";s:3:"148";s:3:"awa";s:3:"149";s:3:"dmu";s:3:"150";s:3:"e n";s:3:"151";s:3:"edm";s:3:"152";s:3:"ina";s:3:"153";s:3:"mak";s:3:"154";s:3:"mun";s:3:"155";s:3:"niy";s:3:"156";s:3:"san";s:3:"157";s:3:"wa ";s:3:"158";s:3:" tu";s:3:"159";s:3:" un";s:3:"160";s:3:"a l";s:3:"161";s:3:"bay";s:3:"162";s:3:"iga";s:3:"163";s:3:"ika";s:3:"164";s:3:"ita";s:3:"165";s:3:"kin";s:3:"166";s:3:"lis";s:3:"167";s:3:"may";s:3:"168";s:3:"os ";s:3:"169";s:3:" ar";s:3:"170";s:3:"ad ";s:3:"171";s:3:"ali";s:3:"172";s:3:"ama";s:3:"173";s:3:"ers";s:3:"174";s:3:"ipa";s:3:"175";s:3:"isa";s:3:"176";s:3:"mao";s:3:"177";s:3:"nim";s:3:"178";s:3:"t s";s:3:"179";s:3:"tin";s:3:"180";s:3:" ak";s:3:"181";s:3:" ap";s:3:"182";s:3:" hi";s:3:"183";s:3:"abo";s:3:"184";s:3:"agp";s:3:"185";s:3:"ano";s:3:"186";s:3:"ata";s:3:"187";s:3:"g i";s:3:"188";s:3:"gan";s:3:"189";s:3:"gka";s:3:"190";s:3:"gpa";s:3:"191";s:3:"i m";s:3:"192";s:3:"iha";s:3:"193";s:3:"k s";s:3:"194";s:3:"law";s:3:"195";s:3:"or ";s:3:"196";s:3:"rs ";s:3:"197";s:3:"siy";s:3:"198";s:3:"tag";s:3:"199";s:3:" al";s:3:"200";s:3:" at";s:3:"201";s:3:" ha";s:3:"202";s:3:" hu";s:3:"203";s:3:" im";s:3:"204";s:3:"a h";s:3:"205";s:3:"bu ";s:3:"206";s:3:"e s";s:3:"207";s:3:"gma";s:3:"208";s:3:"kas";s:3:"209";s:3:"lag";s:3:"210";s:3:"mon";s:3:"211";s:3:"nah";s:3:"212";s:3:"ngo";s:3:"213";s:3:"r s";s:3:"214";s:3:"ra ";s:3:"215";s:3:"sab";s:3:"216";s:3:"sam";s:3:"217";s:3:"sul";s:3:"218";s:3:"uba";s:3:"219";s:3:"uha";s:3:"220";s:3:" lo";s:3:"221";s:3:" re";s:3:"222";s:3:"ada";s:3:"223";s:3:"aki";s:3:"224";s:3:"aya";s:3:"225";s:3:"bah";s:3:"226";s:3:"ce ";s:3:"227";s:3:"d n";s:3:"228";s:3:"lab";s:3:"229";s:3:"pa ";s:3:"230";s:3:"pak";s:3:"231";s:3:"s n";s:3:"232";s:3:"s s";s:3:"233";s:3:"tan";s:3:"234";s:3:"taw";s:3:"235";s:3:"te ";s:3:"236";s:3:"uma";s:3:"237";s:3:"ura";s:3:"238";s:3:" in";s:3:"239";s:3:" lu";s:3:"240";s:3:"a c";s:3:"241";s:3:"abi";s:3:"242";s:3:"at ";s:3:"243";s:3:"awo";s:3:"244";s:3:"bat";s:3:"245";s:3:"dal";s:3:"246";s:3:"dla";s:3:"247";s:3:"ele";s:3:"248";s:3:"g t";s:3:"249";s:3:"g u";s:3:"250";s:3:"gay";s:3:"251";s:3:"go ";s:3:"252";s:3:"hab";s:3:"253";s:3:"hin";s:3:"254";s:3:"i e";s:3:"255";s:3:"i n";s:3:"256";s:3:"kab";s:3:"257";s:3:"kap";s:3:"258";s:3:"lay";s:3:"259";s:3:"lin";s:3:"260";s:3:"nil";s:3:"261";s:3:"pam";s:3:"262";s:3:"pas";s:3:"263";s:3:"pro";s:3:"264";s:3:"pul";s:3:"265";s:3:"ta ";s:3:"266";s:3:"ton";s:3:"267";s:3:"uga";s:3:"268";s:3:"ugm";s:3:"269";s:3:"unt";s:3:"270";s:3:" co";s:3:"271";s:3:" gu";s:3:"272";s:3:" mi";s:3:"273";s:3:" pi";s:3:"274";s:3:" ti";s:3:"275";s:3:"a o";s:3:"276";s:3:"abu";s:3:"277";s:3:"adl";s:3:"278";s:3:"ado";s:3:"279";s:3:"agh";s:3:"280";s:3:"agk";s:3:"281";s:3:"ao ";s:3:"282";s:3:"art";s:3:"283";s:3:"bal";s:3:"284";s:3:"cit";s:3:"285";s:3:"di ";s:3:"286";s:3:"dto";s:3:"287";s:3:"dun";s:3:"288";s:3:"ent";s:3:"289";s:3:"g e";s:3:"290";s:3:"gon";s:3:"291";s:3:"gug";s:3:"292";s:3:"ia ";s:3:"293";s:3:"iba";s:3:"294";s:3:"ice";s:3:"295";s:3:"in ";s:3:"296";s:3:"inu";s:3:"297";s:3:"it ";s:3:"298";s:3:"kaa";s:3:"299";}s:8:"croatian";a:300:{s:3:"je ";s:1:"0";s:3:" na";s:1:"1";s:3:" pr";s:1:"2";s:3:" po";s:1:"3";s:3:"na ";s:1:"4";s:3:" je";s:1:"5";s:3:" za";s:1:"6";s:3:"ije";s:1:"7";s:3:"ne ";s:1:"8";s:3:" i ";s:1:"9";s:3:"ti ";s:2:"10";s:3:"da ";s:2:"11";s:3:" ko";s:2:"12";s:3:" ne";s:2:"13";s:3:"li ";s:2:"14";s:3:" bi";s:2:"15";s:3:" da";s:2:"16";s:3:" u ";s:2:"17";s:3:"ma ";s:2:"18";s:3:"mo ";s:2:"19";s:3:"a n";s:2:"20";s:3:"ih ";s:2:"21";s:3:"za ";s:2:"22";s:3:"a s";s:2:"23";s:3:"ko ";s:2:"24";s:3:"i s";s:2:"25";s:3:"a p";s:2:"26";s:3:"koj";s:2:"27";s:3:"pro";s:2:"28";s:3:"ju ";s:2:"29";s:3:"se ";s:2:"30";s:3:" go";s:2:"31";s:3:"ost";s:2:"32";s:3:"to ";s:2:"33";s:3:"va ";s:2:"34";s:3:" do";s:2:"35";s:3:" to";s:2:"36";s:3:"e n";s:2:"37";s:3:"i p";s:2:"38";s:3:" od";s:2:"39";s:3:" ra";s:2:"40";s:3:"no ";s:2:"41";s:3:"ako";s:2:"42";s:3:"ka ";s:2:"43";s:3:"ni ";s:2:"44";s:3:" ka";s:2:"45";s:3:" se";s:2:"46";s:3:" mo";s:2:"47";s:3:" st";s:2:"48";s:3:"i n";s:2:"49";s:3:"ima";s:2:"50";s:3:"ja ";s:2:"51";s:3:"pri";s:2:"52";s:3:"vat";s:2:"53";s:3:"sta";s:2:"54";s:3:" su";s:2:"55";s:3:"ati";s:2:"56";s:3:"e p";s:2:"57";s:3:"ta ";s:2:"58";s:3:"tsk";s:2:"59";s:3:"e i";s:2:"60";s:3:"nij";s:2:"61";s:3:" tr";s:2:"62";s:3:"cij";s:2:"63";s:3:"jen";s:2:"64";s:3:"nos";s:2:"65";s:3:"o s";s:2:"66";s:3:" iz";s:2:"67";s:3:"om ";s:2:"68";s:3:"tro";s:2:"69";s:3:"ili";s:2:"70";s:3:"iti";s:2:"71";s:3:"pos";s:2:"72";s:3:" al";s:2:"73";s:3:"a i";s:2:"74";s:3:"a o";s:2:"75";s:3:"e s";s:2:"76";s:3:"ija";s:2:"77";s:3:"ini";s:2:"78";s:3:"pre";s:2:"79";s:3:"str";s:2:"80";s:3:"la ";s:2:"81";s:3:"og ";s:2:"82";s:3:"ovo";s:2:"83";s:3:" sv";s:2:"84";s:3:"ekt";s:2:"85";s:3:"nje";s:2:"86";s:3:"o p";s:2:"87";s:3:"odi";s:2:"88";s:3:"rva";s:2:"89";s:3:" ni";s:2:"90";s:3:"ali";s:2:"91";s:3:"min";s:2:"92";s:3:"rij";s:2:"93";s:3:"a t";s:2:"94";s:3:"a z";s:2:"95";s:3:"ats";s:2:"96";s:3:"iva";s:2:"97";s:3:"o t";s:2:"98";s:3:"od ";s:2:"99";s:3:"oje";s:3:"100";s:3:"ra ";s:3:"101";s:3:" hr";s:3:"102";s:3:"a m";s:3:"103";s:3:"a u";s:3:"104";s:3:"hrv";s:3:"105";s:3:"im ";s:3:"106";s:3:"ke ";s:3:"107";s:3:"o i";s:3:"108";s:3:"ovi";s:3:"109";s:3:"red";s:3:"110";s:3:"riv";s:3:"111";s:3:"te ";s:3:"112";s:3:"bi ";s:3:"113";s:3:"e o";s:3:"114";s:3:"god";s:3:"115";s:3:"i d";s:3:"116";s:3:"lek";s:3:"117";s:3:"umi";s:3:"118";s:3:"zvo";s:3:"119";s:3:"din";s:3:"120";s:3:"e u";s:3:"121";s:3:"ene";s:3:"122";s:3:"jed";s:3:"123";s:3:"ji ";s:3:"124";s:3:"lje";s:3:"125";s:3:"nog";s:3:"126";s:3:"su ";s:3:"127";s:3:" a ";s:3:"128";s:3:" el";s:3:"129";s:3:" mi";s:3:"130";s:3:" o ";s:3:"131";s:3:"a d";s:3:"132";s:3:"alu";s:3:"133";s:3:"ele";s:3:"134";s:3:"i u";s:3:"135";s:3:"izv";s:3:"136";s:3:"ktr";s:3:"137";s:3:"lum";s:3:"138";s:3:"o d";s:3:"139";s:3:"ori";s:3:"140";s:3:"rad";s:3:"141";s:3:"sto";s:3:"142";s:3:"a k";s:3:"143";s:3:"anj";s:3:"144";s:3:"ava";s:3:"145";s:3:"e k";s:3:"146";s:3:"men";s:3:"147";s:3:"nic";s:3:"148";s:3:"o j";s:3:"149";s:3:"oj ";s:3:"150";s:3:"ove";s:3:"151";s:3:"ski";s:3:"152";s:3:"tvr";s:3:"153";s:3:"una";s:3:"154";s:3:"vor";s:3:"155";s:3:" di";s:3:"156";s:3:" no";s:3:"157";s:3:" s ";s:3:"158";s:3:" ta";s:3:"159";s:3:" tv";s:3:"160";s:3:"i i";s:3:"161";s:3:"i o";s:3:"162";s:3:"kak";s:3:"163";s:4:"roš";s:3:"164";s:3:"sko";s:3:"165";s:3:"vod";s:3:"166";s:3:" sa";s:3:"167";s:4:" će";s:3:"168";s:3:"a b";s:3:"169";s:3:"adi";s:3:"170";s:3:"amo";s:3:"171";s:3:"eni";s:3:"172";s:3:"gov";s:3:"173";s:3:"iju";s:3:"174";s:3:"ku ";s:3:"175";s:3:"o n";s:3:"176";s:3:"ora";s:3:"177";s:3:"rav";s:3:"178";s:3:"ruj";s:3:"179";s:3:"smo";s:3:"180";s:3:"tav";s:3:"181";s:3:"tru";s:3:"182";s:3:"u p";s:3:"183";s:3:"ve ";s:3:"184";s:3:" in";s:3:"185";s:3:" pl";s:3:"186";s:3:"aci";s:3:"187";s:3:"bit";s:3:"188";s:3:"de ";s:3:"189";s:4:"diš";s:3:"190";s:3:"ema";s:3:"191";s:3:"i m";s:3:"192";s:3:"ika";s:3:"193";s:4:"išt";s:3:"194";s:3:"jer";s:3:"195";s:3:"ki ";s:3:"196";s:3:"mog";s:3:"197";s:3:"nik";s:3:"198";s:3:"nov";s:3:"199";s:3:"nu ";s:3:"200";s:3:"oji";s:3:"201";s:3:"oli";s:3:"202";s:3:"pla";s:3:"203";s:3:"pod";s:3:"204";s:3:"st ";s:3:"205";s:3:"sti";s:3:"206";s:3:"tra";s:3:"207";s:3:"tre";s:3:"208";s:3:"vo ";s:3:"209";s:3:" sm";s:3:"210";s:4:" št";s:3:"211";s:3:"dan";s:3:"212";s:3:"e z";s:3:"213";s:3:"i t";s:3:"214";s:3:"io ";s:3:"215";s:3:"ist";s:3:"216";s:3:"kon";s:3:"217";s:3:"lo ";s:3:"218";s:3:"stv";s:3:"219";s:3:"u s";s:3:"220";s:3:"uje";s:3:"221";s:3:"ust";s:3:"222";s:4:"će ";s:3:"223";s:4:"ći ";s:3:"224";s:4:"što";s:3:"225";s:3:" dr";s:3:"226";s:3:" im";s:3:"227";s:3:" li";s:3:"228";s:3:"ada";s:3:"229";s:3:"aft";s:3:"230";s:3:"ani";s:3:"231";s:3:"ao ";s:3:"232";s:3:"ars";s:3:"233";s:3:"ata";s:3:"234";s:3:"e t";s:3:"235";s:3:"emo";s:3:"236";s:3:"i k";s:3:"237";s:3:"ine";s:3:"238";s:3:"jem";s:3:"239";s:3:"kov";s:3:"240";s:3:"lik";s:3:"241";s:3:"lji";s:3:"242";s:3:"mje";s:3:"243";s:3:"naf";s:3:"244";s:3:"ner";s:3:"245";s:3:"nih";s:3:"246";s:3:"nja";s:3:"247";s:3:"ogo";s:3:"248";s:3:"oiz";s:3:"249";s:3:"ome";s:3:"250";s:3:"pot";s:3:"251";s:3:"ran";s:3:"252";s:3:"ri ";s:3:"253";s:3:"roi";s:3:"254";s:3:"rtk";s:3:"255";s:3:"ska";s:3:"256";s:3:"ter";s:3:"257";s:3:"u i";s:3:"258";s:3:"u o";s:3:"259";s:3:"vi ";s:3:"260";s:3:"vrt";s:3:"261";s:3:" me";s:3:"262";s:3:" ug";s:3:"263";s:3:"ak ";s:3:"264";s:3:"ama";s:3:"265";s:4:"drž";s:3:"266";s:3:"e e";s:3:"267";s:3:"e g";s:3:"268";s:3:"e m";s:3:"269";s:3:"em ";s:3:"270";s:3:"eme";s:3:"271";s:3:"enj";s:3:"272";s:3:"ent";s:3:"273";s:3:"er ";s:3:"274";s:3:"ere";s:3:"275";s:3:"erg";s:3:"276";s:3:"eur";s:3:"277";s:3:"go ";s:3:"278";s:3:"i b";s:3:"279";s:3:"i z";s:3:"280";s:3:"jet";s:3:"281";s:3:"ksi";s:3:"282";s:3:"o u";s:3:"283";s:3:"oda";s:3:"284";s:3:"ona";s:3:"285";s:3:"pra";s:3:"286";s:3:"reb";s:3:"287";s:3:"rem";s:3:"288";s:3:"rop";s:3:"289";s:3:"tri";s:3:"290";s:4:"žav";s:3:"291";s:3:" ci";s:3:"292";s:3:" eu";s:3:"293";s:3:" re";s:3:"294";s:3:" te";s:3:"295";s:3:" uv";s:3:"296";s:3:" ve";s:3:"297";s:3:"aju";s:3:"298";s:3:"an ";s:3:"299";}s:5:"czech";a:300:{s:3:" pr";s:1:"0";s:3:" po";s:1:"1";s:4:"ní ";s:1:"2";s:3:"pro";s:1:"3";s:3:" na";s:1:"4";s:3:"na ";s:1:"5";s:4:" př";s:1:"6";s:3:"ch ";s:1:"7";s:3:" je";s:1:"8";s:3:" ne";s:1:"9";s:4:"že ";s:2:"10";s:4:" že";s:2:"11";s:3:" se";s:2:"12";s:3:" do";s:2:"13";s:3:" ro";s:2:"14";s:3:" st";s:2:"15";s:3:" v ";s:2:"16";s:3:" ve";s:2:"17";s:4:"pře";s:2:"18";s:3:"se ";s:2:"19";s:3:"ho ";s:2:"20";s:3:"sta";s:2:"21";s:3:" to";s:2:"22";s:3:" vy";s:2:"23";s:3:" za";s:2:"24";s:3:"ou ";s:2:"25";s:3:" a ";s:2:"26";s:3:"to ";s:2:"27";s:3:" by";s:2:"28";s:3:"la ";s:2:"29";s:3:"ce ";s:2:"30";s:3:"e v";s:2:"31";s:3:"ist";s:2:"32";s:3:"le ";s:2:"33";s:3:"pod";s:2:"34";s:4:"í p";s:2:"35";s:3:" vl";s:2:"36";s:3:"e n";s:2:"37";s:3:"e s";s:2:"38";s:3:"je ";s:2:"39";s:4:"ké ";s:2:"40";s:3:"by ";s:2:"41";s:3:"em ";s:2:"42";s:4:"ých";s:2:"43";s:3:" od";s:2:"44";s:3:"ova";s:2:"45";s:4:"řed";s:2:"46";s:3:"dy ";s:2:"47";s:4:"ení";s:2:"48";s:3:"kon";s:2:"49";s:3:"li ";s:2:"50";s:4:"ně ";s:2:"51";s:3:"str";s:2:"52";s:4:" zá";s:2:"53";s:3:"ve ";s:2:"54";s:3:" ka";s:2:"55";s:3:" sv";s:2:"56";s:3:"e p";s:2:"57";s:3:"it ";s:2:"58";s:4:"lád";s:2:"59";s:3:"oho";s:2:"60";s:3:"rov";s:2:"61";s:3:"roz";s:2:"62";s:3:"ter";s:2:"63";s:4:"vlá";s:2:"64";s:4:"ím ";s:2:"65";s:3:" ko";s:2:"66";s:3:"hod";s:2:"67";s:3:"nis";s:2:"68";s:5:"pří";s:2:"69";s:4:"ský";s:2:"70";s:3:" mi";s:2:"71";s:3:" ob";s:2:"72";s:3:" so";s:2:"73";s:3:"a p";s:2:"74";s:3:"ali";s:2:"75";s:3:"bud";s:2:"76";s:3:"edn";s:2:"77";s:3:"ick";s:2:"78";s:3:"kte";s:2:"79";s:3:"ku ";s:2:"80";s:3:"o s";s:2:"81";s:3:"al ";s:2:"82";s:3:"ci ";s:2:"83";s:3:"e t";s:2:"84";s:3:"il ";s:2:"85";s:3:"ny ";s:2:"86";s:4:"né ";s:2:"87";s:3:"odl";s:2:"88";s:4:"ová";s:2:"89";s:3:"rot";s:2:"90";s:3:"sou";s:2:"91";s:5:"ání";s:2:"92";s:3:" bu";s:2:"93";s:3:" mo";s:2:"94";s:3:" o ";s:2:"95";s:3:"ast";s:2:"96";s:3:"byl";s:2:"97";s:3:"de ";s:2:"98";s:3:"ek ";s:2:"99";s:3:"ost";s:3:"100";s:4:" mí";s:3:"101";s:3:" ta";s:3:"102";s:3:"es ";s:3:"103";s:3:"jed";s:3:"104";s:3:"ky ";s:3:"105";s:3:"las";s:3:"106";s:3:"m p";s:3:"107";s:3:"nes";s:3:"108";s:4:"ním";s:3:"109";s:3:"ran";s:3:"110";s:3:"rem";s:3:"111";s:3:"ros";s:3:"112";s:4:"ého";s:3:"113";s:3:" de";s:3:"114";s:3:" kt";s:3:"115";s:3:" ni";s:3:"116";s:3:" si";s:3:"117";s:4:" vý";s:3:"118";s:3:"at ";s:3:"119";s:4:"jí ";s:3:"120";s:4:"ký ";s:3:"121";s:3:"mi ";s:3:"122";s:3:"pre";s:3:"123";s:3:"tak";s:3:"124";s:3:"tan";s:3:"125";s:3:"y v";s:3:"126";s:4:"řek";s:3:"127";s:3:" ch";s:3:"128";s:3:" li";s:3:"129";s:4:" ná";s:3:"130";s:3:" pa";s:3:"131";s:4:" ře";s:3:"132";s:3:"da ";s:3:"133";s:3:"dle";s:3:"134";s:3:"dne";s:3:"135";s:3:"i p";s:3:"136";s:3:"i v";s:3:"137";s:3:"ly ";s:3:"138";s:3:"min";s:3:"139";s:3:"o n";s:3:"140";s:3:"o v";s:3:"141";s:3:"pol";s:3:"142";s:3:"tra";s:3:"143";s:3:"val";s:3:"144";s:4:"vní";s:3:"145";s:4:"ích";s:3:"146";s:4:"ý p";s:3:"147";s:4:"řej";s:3:"148";s:3:" ce";s:3:"149";s:3:" kd";s:3:"150";s:3:" le";s:3:"151";s:3:"a s";s:3:"152";s:3:"a z";s:3:"153";s:3:"cen";s:3:"154";s:3:"e k";s:3:"155";s:3:"eds";s:3:"156";s:3:"ekl";s:3:"157";s:3:"emi";s:3:"158";s:3:"kl ";s:3:"159";s:3:"lat";s:3:"160";s:3:"lo ";s:3:"161";s:4:"mié";s:3:"162";s:3:"nov";s:3:"163";s:3:"pra";s:3:"164";s:3:"sku";s:3:"165";s:4:"ské";s:3:"166";s:3:"sti";s:3:"167";s:3:"tav";s:3:"168";s:3:"ti ";s:3:"169";s:3:"ty ";s:3:"170";s:4:"ván";s:3:"171";s:4:"vé ";s:3:"172";s:3:"y n";s:3:"173";s:3:"y s";s:3:"174";s:4:"í s";s:3:"175";s:4:"í v";s:3:"176";s:4:"ě p";s:3:"177";s:3:" dn";s:3:"178";s:4:" ně";s:3:"179";s:3:" sp";s:3:"180";s:4:" čs";s:3:"181";s:3:"a n";s:3:"182";s:3:"a t";s:3:"183";s:3:"ak ";s:3:"184";s:4:"dní";s:3:"185";s:3:"doh";s:3:"186";s:3:"e b";s:3:"187";s:3:"e m";s:3:"188";s:3:"ejn";s:3:"189";s:3:"ena";s:3:"190";s:3:"est";s:3:"191";s:3:"ini";s:3:"192";s:3:"m z";s:3:"193";s:3:"nal";s:3:"194";s:3:"nou";s:3:"195";s:4:"ná ";s:3:"196";s:3:"ovi";s:3:"197";s:4:"ové";s:3:"198";s:4:"ový";s:3:"199";s:3:"rsk";s:3:"200";s:4:"stá";s:3:"201";s:4:"tí ";s:3:"202";s:4:"tře";s:3:"203";s:4:"tů ";s:3:"204";s:3:"ude";s:3:"205";s:3:"za ";s:3:"206";s:4:"é p";s:3:"207";s:4:"ém ";s:3:"208";s:4:"í d";s:3:"209";s:3:" ir";s:3:"210";s:3:" zv";s:3:"211";s:3:"ale";s:3:"212";s:4:"aně";s:3:"213";s:3:"ave";s:3:"214";s:4:"cké";s:3:"215";s:3:"den";s:3:"216";s:3:"e z";s:3:"217";s:3:"ech";s:3:"218";s:3:"en ";s:3:"219";s:4:"erý";s:3:"220";s:3:"hla";s:3:"221";s:3:"i s";s:3:"222";s:4:"iér";s:3:"223";s:3:"lov";s:3:"224";s:3:"mu ";s:3:"225";s:3:"neb";s:3:"226";s:3:"nic";s:3:"227";s:3:"o b";s:3:"228";s:3:"o m";s:3:"229";s:3:"pad";s:3:"230";s:3:"pot";s:3:"231";s:3:"rav";s:3:"232";s:3:"rop";s:3:"233";s:4:"rý ";s:3:"234";s:3:"sed";s:3:"235";s:3:"si ";s:3:"236";s:3:"t p";s:3:"237";s:3:"tic";s:3:"238";s:3:"tu ";s:3:"239";s:4:"tě ";s:3:"240";s:3:"u p";s:3:"241";s:3:"u v";s:3:"242";s:4:"vá ";s:3:"243";s:5:"výš";s:3:"244";s:4:"zvý";s:3:"245";s:5:"ční";s:3:"246";s:5:"ří ";s:3:"247";s:4:"ům ";s:3:"248";s:3:" bl";s:3:"249";s:3:" br";s:3:"250";s:3:" ho";s:3:"251";s:3:" ja";s:3:"252";s:3:" re";s:3:"253";s:3:" s ";s:3:"254";s:3:" z ";s:3:"255";s:3:" zd";s:3:"256";s:3:"a v";s:3:"257";s:3:"ani";s:3:"258";s:3:"ato";s:3:"259";s:3:"bla";s:3:"260";s:3:"bri";s:3:"261";s:4:"ečn";s:3:"262";s:4:"eře";s:3:"263";s:3:"h v";s:3:"264";s:3:"i n";s:3:"265";s:3:"ie ";s:3:"266";s:3:"ila";s:3:"267";s:3:"irs";s:3:"268";s:3:"ite";s:3:"269";s:3:"kov";s:3:"270";s:3:"nos";s:3:"271";s:3:"o o";s:3:"272";s:3:"o p";s:3:"273";s:3:"oce";s:3:"274";s:3:"ody";s:3:"275";s:3:"ohl";s:3:"276";s:3:"oli";s:3:"277";s:3:"ovo";s:3:"278";s:3:"pla";s:3:"279";s:4:"poč";s:3:"280";s:4:"prá";s:3:"281";s:3:"ra ";s:3:"282";s:3:"rit";s:3:"283";s:3:"rod";s:3:"284";s:3:"ry ";s:3:"285";s:3:"sd ";s:3:"286";s:3:"sko";s:3:"287";s:3:"ssd";s:3:"288";s:3:"tel";s:3:"289";s:3:"u s";s:3:"290";s:3:"vat";s:3:"291";s:4:"veř";s:3:"292";s:3:"vit";s:3:"293";s:3:"vla";s:3:"294";s:3:"y p";s:3:"295";s:4:"áln";s:3:"296";s:4:"čss";s:3:"297";s:4:"šen";s:3:"298";s:3:" al";s:3:"299";}s:6:"danish";a:300:{s:3:"er ";s:1:"0";s:3:"en ";s:1:"1";s:3:" de";s:1:"2";s:3:"et ";s:1:"3";s:3:"der";s:1:"4";s:3:"de ";s:1:"5";s:3:"for";s:1:"6";s:3:" fo";s:1:"7";s:3:" i ";s:1:"8";s:3:"at ";s:1:"9";s:3:" at";s:2:"10";s:3:"re ";s:2:"11";s:3:"det";s:2:"12";s:3:" ha";s:2:"13";s:3:"nde";s:2:"14";s:3:"ere";s:2:"15";s:3:"ing";s:2:"16";s:3:"den";s:2:"17";s:3:" me";s:2:"18";s:3:" og";s:2:"19";s:3:"ger";s:2:"20";s:3:"ter";s:2:"21";s:3:" er";s:2:"22";s:3:" si";s:2:"23";s:3:"and";s:2:"24";s:3:" af";s:2:"25";s:3:"or ";s:2:"26";s:3:" st";s:2:"27";s:3:" ti";s:2:"28";s:3:" en";s:2:"29";s:3:"og ";s:2:"30";s:3:"ar ";s:2:"31";s:3:"il ";s:2:"32";s:3:"r s";s:2:"33";s:3:"ige";s:2:"34";s:3:"til";s:2:"35";s:3:"ke ";s:2:"36";s:3:"r e";s:2:"37";s:3:"af ";s:2:"38";s:3:"kke";s:2:"39";s:3:" ma";s:2:"40";s:4:" på";s:2:"41";s:3:"om ";s:2:"42";s:4:"på ";s:2:"43";s:3:"ed ";s:2:"44";s:3:"ge ";s:2:"45";s:3:"end";s:2:"46";s:3:"nge";s:2:"47";s:3:"t s";s:2:"48";s:3:"e s";s:2:"49";s:3:"ler";s:2:"50";s:3:" sk";s:2:"51";s:3:"els";s:2:"52";s:3:"ern";s:2:"53";s:3:"sig";s:2:"54";s:3:"ne ";s:2:"55";s:3:"lig";s:2:"56";s:3:"r d";s:2:"57";s:3:"ska";s:2:"58";s:3:" vi";s:2:"59";s:3:"har";s:2:"60";s:3:" be";s:2:"61";s:3:" se";s:2:"62";s:3:"an ";s:2:"63";s:3:"ikk";s:2:"64";s:3:"lle";s:2:"65";s:3:"gen";s:2:"66";s:3:"n f";s:2:"67";s:3:"ste";s:2:"68";s:3:"t a";s:2:"69";s:3:"t d";s:2:"70";s:3:"rin";s:2:"71";s:3:" ik";s:2:"72";s:3:"es ";s:2:"73";s:3:"ng ";s:2:"74";s:3:"ver";s:2:"75";s:3:"r b";s:2:"76";s:3:"sen";s:2:"77";s:3:"ede";s:2:"78";s:3:"men";s:2:"79";s:3:"r i";s:2:"80";s:3:" he";s:2:"81";s:3:" et";s:2:"82";s:3:"ig ";s:2:"83";s:3:"lan";s:2:"84";s:3:"med";s:2:"85";s:3:"nd ";s:2:"86";s:3:"rne";s:2:"87";s:3:" da";s:2:"88";s:3:" in";s:2:"89";s:3:"e t";s:2:"90";s:3:"mme";s:2:"91";s:3:"und";s:2:"92";s:3:" om";s:2:"93";s:3:"e e";s:2:"94";s:3:"e m";s:2:"95";s:3:"her";s:2:"96";s:3:"le ";s:2:"97";s:3:"r f";s:2:"98";s:3:"t f";s:2:"99";s:4:"så ";s:3:"100";s:3:"te ";s:3:"101";s:3:" so";s:3:"102";s:3:"ele";s:3:"103";s:3:"t e";s:3:"104";s:3:" ko";s:3:"105";s:3:"est";s:3:"106";s:3:"ske";s:3:"107";s:3:" bl";s:3:"108";s:3:"e f";s:3:"109";s:3:"ekt";s:3:"110";s:3:"mar";s:3:"111";s:3:"bru";s:3:"112";s:3:"e a";s:3:"113";s:3:"el ";s:3:"114";s:3:"ers";s:3:"115";s:3:"ret";s:3:"116";s:3:"som";s:3:"117";s:3:"tte";s:3:"118";s:3:"ve ";s:3:"119";s:3:" la";s:3:"120";s:3:" ud";s:3:"121";s:3:" ve";s:3:"122";s:3:"age";s:3:"123";s:3:"e d";s:3:"124";s:3:"e h";s:3:"125";s:3:"lse";s:3:"126";s:3:"man";s:3:"127";s:3:"rug";s:3:"128";s:3:"sel";s:3:"129";s:3:"ser";s:3:"130";s:3:" fi";s:3:"131";s:3:" op";s:3:"132";s:3:" pr";s:3:"133";s:3:"dt ";s:3:"134";s:3:"e i";s:3:"135";s:3:"n m";s:3:"136";s:3:"r m";s:3:"137";s:3:" an";s:3:"138";s:3:" re";s:3:"139";s:3:" sa";s:3:"140";s:3:"ion";s:3:"141";s:3:"ner";s:3:"142";s:3:"res";s:3:"143";s:3:"t i";s:3:"144";s:3:"get";s:3:"145";s:3:"n s";s:3:"146";s:3:"one";s:3:"147";s:3:"orb";s:3:"148";s:3:"t h";s:3:"149";s:3:"vis";s:3:"150";s:4:"år ";s:3:"151";s:3:" fr";s:3:"152";s:3:"bil";s:3:"153";s:3:"e k";s:3:"154";s:3:"ens";s:3:"155";s:3:"ind";s:3:"156";s:3:"omm";s:3:"157";s:3:"t m";s:3:"158";s:3:" hv";s:3:"159";s:3:" je";s:3:"160";s:3:"dan";s:3:"161";s:3:"ent";s:3:"162";s:3:"fte";s:3:"163";s:3:"nin";s:3:"164";s:3:" mi";s:3:"165";s:3:"e o";s:3:"166";s:3:"e p";s:3:"167";s:3:"n o";s:3:"168";s:3:"nte";s:3:"169";s:3:" ku";s:3:"170";s:3:"ell";s:3:"171";s:3:"nas";s:3:"172";s:3:"ore";s:3:"173";s:3:"r h";s:3:"174";s:3:"r k";s:3:"175";s:3:"sta";s:3:"176";s:3:"sto";s:3:"177";s:3:"dag";s:3:"178";s:3:"eri";s:3:"179";s:3:"kun";s:3:"180";s:3:"lde";s:3:"181";s:3:"mer";s:3:"182";s:3:"r a";s:3:"183";s:3:"r v";s:3:"184";s:3:"rek";s:3:"185";s:3:"rer";s:3:"186";s:3:"t o";s:3:"187";s:3:"tor";s:3:"188";s:4:"tør";s:3:"189";s:4:" få";s:3:"190";s:4:" må";s:3:"191";s:3:" to";s:3:"192";s:3:"boe";s:3:"193";s:3:"che";s:3:"194";s:3:"e v";s:3:"195";s:3:"i d";s:3:"196";s:3:"ive";s:3:"197";s:3:"kab";s:3:"198";s:3:"ns ";s:3:"199";s:3:"oel";s:3:"200";s:3:"se ";s:3:"201";s:3:"t v";s:3:"202";s:3:" al";s:3:"203";s:3:" bo";s:3:"204";s:3:" un";s:3:"205";s:3:"ans";s:3:"206";s:3:"dre";s:3:"207";s:3:"ire";s:3:"208";s:4:"køb";s:3:"209";s:3:"ors";s:3:"210";s:3:"ove";s:3:"211";s:3:"ren";s:3:"212";s:3:"t b";s:3:"213";s:4:"ør ";s:3:"214";s:3:" ka";s:3:"215";s:3:"ald";s:3:"216";s:3:"bet";s:3:"217";s:3:"gt ";s:3:"218";s:3:"isk";s:3:"219";s:3:"kal";s:3:"220";s:3:"kom";s:3:"221";s:3:"lev";s:3:"222";s:3:"n d";s:3:"223";s:3:"n i";s:3:"224";s:3:"pri";s:3:"225";s:3:"r p";s:3:"226";s:3:"rbr";s:3:"227";s:4:"søg";s:3:"228";s:3:"tel";s:3:"229";s:4:" så";s:3:"230";s:3:" te";s:3:"231";s:3:" va";s:3:"232";s:3:"al ";s:3:"233";s:3:"dir";s:3:"234";s:3:"eje";s:3:"235";s:3:"fis";s:3:"236";s:4:"gså";s:3:"237";s:3:"isc";s:3:"238";s:3:"jer";s:3:"239";s:3:"ker";s:3:"240";s:3:"ogs";s:3:"241";s:3:"sch";s:3:"242";s:3:"st ";s:3:"243";s:3:"t k";s:3:"244";s:3:"uge";s:3:"245";s:3:" di";s:3:"246";s:3:"ag ";s:3:"247";s:3:"d a";s:3:"248";s:3:"g i";s:3:"249";s:3:"ill";s:3:"250";s:3:"l a";s:3:"251";s:3:"lsk";s:3:"252";s:3:"n a";s:3:"253";s:3:"on ";s:3:"254";s:3:"sam";s:3:"255";s:3:"str";s:3:"256";s:3:"tet";s:3:"257";s:3:"var";s:3:"258";s:3:" mo";s:3:"259";s:3:"art";s:3:"260";s:3:"ash";s:3:"261";s:3:"att";s:3:"262";s:3:"e b";s:3:"263";s:3:"han";s:3:"264";s:3:"hav";s:3:"265";s:3:"kla";s:3:"266";s:3:"kon";s:3:"267";s:3:"n t";s:3:"268";s:3:"ned";s:3:"269";s:3:"r o";s:3:"270";s:3:"ra ";s:3:"271";s:3:"rre";s:3:"272";s:3:"ves";s:3:"273";s:3:"vil";s:3:"274";s:3:" el";s:3:"275";s:3:" kr";s:3:"276";s:3:" ov";s:3:"277";s:3:"ann";s:3:"278";s:3:"e u";s:3:"279";s:3:"ess";s:3:"280";s:3:"fra";s:3:"281";s:3:"g a";s:3:"282";s:3:"g d";s:3:"283";s:3:"int";s:3:"284";s:3:"ngs";s:3:"285";s:3:"rde";s:3:"286";s:3:"tra";s:3:"287";s:4:" år";s:3:"288";s:3:"akt";s:3:"289";s:3:"asi";s:3:"290";s:3:"em ";s:3:"291";s:3:"gel";s:3:"292";s:3:"gym";s:3:"293";s:3:"hol";s:3:"294";s:3:"kan";s:3:"295";s:3:"mna";s:3:"296";s:3:"n h";s:3:"297";s:3:"nsk";s:3:"298";s:3:"old";s:3:"299";}s:5:"dutch";a:300:{s:3:"en ";s:1:"0";s:3:"de ";s:1:"1";s:3:" de";s:1:"2";s:3:"et ";s:1:"3";s:3:"an ";s:1:"4";s:3:" he";s:1:"5";s:3:"er ";s:1:"6";s:3:" va";s:1:"7";s:3:"n d";s:1:"8";s:3:"van";s:1:"9";s:3:"een";s:2:"10";s:3:"het";s:2:"11";s:3:" ge";s:2:"12";s:3:"oor";s:2:"13";s:3:" ee";s:2:"14";s:3:"der";s:2:"15";s:3:" en";s:2:"16";s:3:"ij ";s:2:"17";s:3:"aar";s:2:"18";s:3:"gen";s:2:"19";s:3:"te ";s:2:"20";s:3:"ver";s:2:"21";s:3:" in";s:2:"22";s:3:" me";s:2:"23";s:3:"aan";s:2:"24";s:3:"den";s:2:"25";s:3:" we";s:2:"26";s:3:"at ";s:2:"27";s:3:"in ";s:2:"28";s:3:" da";s:2:"29";s:3:" te";s:2:"30";s:3:"eer";s:2:"31";s:3:"nde";s:2:"32";s:3:"ter";s:2:"33";s:3:"ste";s:2:"34";s:3:"n v";s:2:"35";s:3:" vo";s:2:"36";s:3:" zi";s:2:"37";s:3:"ing";s:2:"38";s:3:"n h";s:2:"39";s:3:"voo";s:2:"40";s:3:"is ";s:2:"41";s:3:" op";s:2:"42";s:3:"tie";s:2:"43";s:3:" aa";s:2:"44";s:3:"ede";s:2:"45";s:3:"erd";s:2:"46";s:3:"ers";s:2:"47";s:3:" be";s:2:"48";s:3:"eme";s:2:"49";s:3:"ten";s:2:"50";s:3:"ken";s:2:"51";s:3:"n e";s:2:"52";s:3:" ni";s:2:"53";s:3:" ve";s:2:"54";s:3:"ent";s:2:"55";s:3:"ijn";s:2:"56";s:3:"jn ";s:2:"57";s:3:"mee";s:2:"58";s:3:"iet";s:2:"59";s:3:"n w";s:2:"60";s:3:"ng ";s:2:"61";s:3:"nie";s:2:"62";s:3:" is";s:2:"63";s:3:"cht";s:2:"64";s:3:"dat";s:2:"65";s:3:"ere";s:2:"66";s:3:"ie ";s:2:"67";s:3:"ijk";s:2:"68";s:3:"n b";s:2:"69";s:3:"rde";s:2:"70";s:3:"ar ";s:2:"71";s:3:"e b";s:2:"72";s:3:"e a";s:2:"73";s:3:"met";s:2:"74";s:3:"t d";s:2:"75";s:3:"el ";s:2:"76";s:3:"ond";s:2:"77";s:3:"t h";s:2:"78";s:3:" al";s:2:"79";s:3:"e w";s:2:"80";s:3:"op ";s:2:"81";s:3:"ren";s:2:"82";s:3:" di";s:2:"83";s:3:" on";s:2:"84";s:3:"al ";s:2:"85";s:3:"and";s:2:"86";s:3:"bij";s:2:"87";s:3:"zij";s:2:"88";s:3:" bi";s:2:"89";s:3:" hi";s:2:"90";s:3:" wi";s:2:"91";s:3:"or ";s:2:"92";s:3:"r d";s:2:"93";s:3:"t v";s:2:"94";s:3:" wa";s:2:"95";s:3:"e h";s:2:"96";s:3:"lle";s:2:"97";s:3:"rt ";s:2:"98";s:3:"ang";s:2:"99";s:3:"hij";s:3:"100";s:3:"men";s:3:"101";s:3:"n a";s:3:"102";s:3:"n z";s:3:"103";s:3:"rs ";s:3:"104";s:3:" om";s:3:"105";s:3:"e o";s:3:"106";s:3:"e v";s:3:"107";s:3:"end";s:3:"108";s:3:"est";s:3:"109";s:3:"n t";s:3:"110";s:3:"par";s:3:"111";s:3:" pa";s:3:"112";s:3:" pr";s:3:"113";s:3:" ze";s:3:"114";s:3:"e g";s:3:"115";s:3:"e p";s:3:"116";s:3:"n p";s:3:"117";s:3:"ord";s:3:"118";s:3:"oud";s:3:"119";s:3:"raa";s:3:"120";s:3:"sch";s:3:"121";s:3:"t e";s:3:"122";s:3:"ege";s:3:"123";s:3:"ich";s:3:"124";s:3:"ien";s:3:"125";s:3:"aat";s:3:"126";s:3:"ek ";s:3:"127";s:3:"len";s:3:"128";s:3:"n m";s:3:"129";s:3:"nge";s:3:"130";s:3:"nt ";s:3:"131";s:3:"ove";s:3:"132";s:3:"rd ";s:3:"133";s:3:"wer";s:3:"134";s:3:" ma";s:3:"135";s:3:" mi";s:3:"136";s:3:"daa";s:3:"137";s:3:"e k";s:3:"138";s:3:"lij";s:3:"139";s:3:"mer";s:3:"140";s:3:"n g";s:3:"141";s:3:"n o";s:3:"142";s:3:"om ";s:3:"143";s:3:"sen";s:3:"144";s:3:"t b";s:3:"145";s:3:"wij";s:3:"146";s:3:" ho";s:3:"147";s:3:"e m";s:3:"148";s:3:"ele";s:3:"149";s:3:"gem";s:3:"150";s:3:"heb";s:3:"151";s:3:"pen";s:3:"152";s:3:"ude";s:3:"153";s:3:" bo";s:3:"154";s:3:" ja";s:3:"155";s:3:"die";s:3:"156";s:3:"e e";s:3:"157";s:3:"eli";s:3:"158";s:3:"erk";s:3:"159";s:3:"le ";s:3:"160";s:3:"pro";s:3:"161";s:3:"rij";s:3:"162";s:3:" er";s:3:"163";s:3:" za";s:3:"164";s:3:"e d";s:3:"165";s:3:"ens";s:3:"166";s:3:"ind";s:3:"167";s:3:"ke ";s:3:"168";s:3:"n k";s:3:"169";s:3:"nd ";s:3:"170";s:3:"nen";s:3:"171";s:3:"nte";s:3:"172";s:3:"r h";s:3:"173";s:3:"s d";s:3:"174";s:3:"s e";s:3:"175";s:3:"t z";s:3:"176";s:3:" b ";s:3:"177";s:3:" co";s:3:"178";s:3:" ik";s:3:"179";s:3:" ko";s:3:"180";s:3:" ov";s:3:"181";s:3:"eke";s:3:"182";s:3:"hou";s:3:"183";s:3:"ik ";s:3:"184";s:3:"iti";s:3:"185";s:3:"lan";s:3:"186";s:3:"ns ";s:3:"187";s:3:"t g";s:3:"188";s:3:"t m";s:3:"189";s:3:" do";s:3:"190";s:3:" le";s:3:"191";s:3:" zo";s:3:"192";s:3:"ams";s:3:"193";s:3:"e z";s:3:"194";s:3:"g v";s:3:"195";s:3:"it ";s:3:"196";s:3:"je ";s:3:"197";s:3:"ls ";s:3:"198";s:3:"maa";s:3:"199";s:3:"n i";s:3:"200";s:3:"nke";s:3:"201";s:3:"rke";s:3:"202";s:3:"uit";s:3:"203";s:3:" ha";s:3:"204";s:3:" ka";s:3:"205";s:3:" mo";s:3:"206";s:3:" re";s:3:"207";s:3:" st";s:3:"208";s:3:" to";s:3:"209";s:3:"age";s:3:"210";s:3:"als";s:3:"211";s:3:"ark";s:3:"212";s:3:"art";s:3:"213";s:3:"ben";s:3:"214";s:3:"e r";s:3:"215";s:3:"e s";s:3:"216";s:3:"ert";s:3:"217";s:3:"eze";s:3:"218";s:3:"ht ";s:3:"219";s:3:"ijd";s:3:"220";s:3:"lem";s:3:"221";s:3:"r v";s:3:"222";s:3:"rte";s:3:"223";s:3:"t p";s:3:"224";s:3:"zeg";s:3:"225";s:3:"zic";s:3:"226";s:3:"aak";s:3:"227";s:3:"aal";s:3:"228";s:3:"ag ";s:3:"229";s:3:"ale";s:3:"230";s:3:"bbe";s:3:"231";s:3:"ch ";s:3:"232";s:3:"e t";s:3:"233";s:3:"ebb";s:3:"234";s:3:"erz";s:3:"235";s:3:"ft ";s:3:"236";s:3:"ge ";s:3:"237";s:3:"led";s:3:"238";s:3:"mst";s:3:"239";s:3:"n n";s:3:"240";s:3:"oek";s:3:"241";s:3:"r i";s:3:"242";s:3:"t o";s:3:"243";s:3:"t w";s:3:"244";s:3:"tel";s:3:"245";s:3:"tte";s:3:"246";s:3:"uur";s:3:"247";s:3:"we ";s:3:"248";s:3:"zit";s:3:"249";s:3:" af";s:3:"250";s:3:" li";s:3:"251";s:3:" ui";s:3:"252";s:3:"ak ";s:3:"253";s:3:"all";s:3:"254";s:3:"aut";s:3:"255";s:3:"doo";s:3:"256";s:3:"e i";s:3:"257";s:3:"ene";s:3:"258";s:3:"erg";s:3:"259";s:3:"ete";s:3:"260";s:3:"ges";s:3:"261";s:3:"hee";s:3:"262";s:3:"jaa";s:3:"263";s:3:"jke";s:3:"264";s:3:"kee";s:3:"265";s:3:"kel";s:3:"266";s:3:"kom";s:3:"267";s:3:"lee";s:3:"268";s:3:"moe";s:3:"269";s:3:"n s";s:3:"270";s:3:"ort";s:3:"271";s:3:"rec";s:3:"272";s:3:"s o";s:3:"273";s:3:"s v";s:3:"274";s:3:"teg";s:3:"275";s:3:"tij";s:3:"276";s:3:"ven";s:3:"277";s:3:"waa";s:3:"278";s:3:"wel";s:3:"279";s:3:" an";s:3:"280";s:3:" au";s:3:"281";s:3:" bu";s:3:"282";s:3:" gr";s:3:"283";s:3:" pl";s:3:"284";s:3:" ti";s:3:"285";s:3:"'' ";s:3:"286";s:3:"ade";s:3:"287";s:3:"dag";s:3:"288";s:3:"e l";s:3:"289";s:3:"ech";s:3:"290";s:3:"eel";s:3:"291";s:3:"eft";s:3:"292";s:3:"ger";s:3:"293";s:3:"gt ";s:3:"294";s:3:"ig ";s:3:"295";s:3:"itt";s:3:"296";s:3:"j d";s:3:"297";s:3:"ppe";s:3:"298";s:3:"rda";s:3:"299";}s:7:"english";a:300:{s:3:" th";s:1:"0";s:3:"the";s:1:"1";s:3:"he ";s:1:"2";s:3:"ed ";s:1:"3";s:3:" to";s:1:"4";s:3:" in";s:1:"5";s:3:"er ";s:1:"6";s:3:"ing";s:1:"7";s:3:"ng ";s:1:"8";s:3:" an";s:1:"9";s:3:"nd ";s:2:"10";s:3:" of";s:2:"11";s:3:"and";s:2:"12";s:3:"to ";s:2:"13";s:3:"of ";s:2:"14";s:3:" co";s:2:"15";s:3:"at ";s:2:"16";s:3:"on ";s:2:"17";s:3:"in ";s:2:"18";s:3:" a ";s:2:"19";s:3:"d t";s:2:"20";s:3:" he";s:2:"21";s:3:"e t";s:2:"22";s:3:"ion";s:2:"23";s:3:"es ";s:2:"24";s:3:" re";s:2:"25";s:3:"re ";s:2:"26";s:3:"hat";s:2:"27";s:3:" sa";s:2:"28";s:3:" st";s:2:"29";s:3:" ha";s:2:"30";s:3:"her";s:2:"31";s:3:"tha";s:2:"32";s:3:"tio";s:2:"33";s:3:"or ";s:2:"34";s:3:" ''";s:2:"35";s:3:"en ";s:2:"36";s:3:" wh";s:2:"37";s:3:"e s";s:2:"38";s:3:"ent";s:2:"39";s:3:"n t";s:2:"40";s:3:"s a";s:2:"41";s:3:"as ";s:2:"42";s:3:"for";s:2:"43";s:3:"is ";s:2:"44";s:3:"t t";s:2:"45";s:3:" be";s:2:"46";s:3:"ld ";s:2:"47";s:3:"e a";s:2:"48";s:3:"rs ";s:2:"49";s:3:" wa";s:2:"50";s:3:"ut ";s:2:"51";s:3:"ve ";s:2:"52";s:3:"ll ";s:2:"53";s:3:"al ";s:2:"54";s:3:" ma";s:2:"55";s:3:"e i";s:2:"56";s:3:" fo";s:2:"57";s:3:"'s ";s:2:"58";s:3:"an ";s:2:"59";s:3:"est";s:2:"60";s:3:" hi";s:2:"61";s:3:" mo";s:2:"62";s:3:" se";s:2:"63";s:3:" pr";s:2:"64";s:3:"s t";s:2:"65";s:3:"ate";s:2:"66";s:3:"st ";s:2:"67";s:3:"ter";s:2:"68";s:3:"ere";s:2:"69";s:3:"ted";s:2:"70";s:3:"nt ";s:2:"71";s:3:"ver";s:2:"72";s:3:"d a";s:2:"73";s:3:" wi";s:2:"74";s:3:"se ";s:2:"75";s:3:"e c";s:2:"76";s:3:"ect";s:2:"77";s:3:"ns ";s:2:"78";s:3:" on";s:2:"79";s:3:"ly ";s:2:"80";s:3:"tol";s:2:"81";s:3:"ey ";s:2:"82";s:3:"r t";s:2:"83";s:3:" ca";s:2:"84";s:3:"ati";s:2:"85";s:3:"ts ";s:2:"86";s:3:"all";s:2:"87";s:3:" no";s:2:"88";s:3:"his";s:2:"89";s:3:"s o";s:2:"90";s:3:"ers";s:2:"91";s:3:"con";s:2:"92";s:3:"e o";s:2:"93";s:3:"ear";s:2:"94";s:3:"f t";s:2:"95";s:3:"e w";s:2:"96";s:3:"was";s:2:"97";s:3:"ons";s:2:"98";s:3:"sta";s:2:"99";s:3:"'' ";s:3:"100";s:3:"sti";s:3:"101";s:3:"n a";s:3:"102";s:3:"sto";s:3:"103";s:3:"t h";s:3:"104";s:3:" we";s:3:"105";s:3:"id ";s:3:"106";s:3:"th ";s:3:"107";s:3:" it";s:3:"108";s:3:"ce ";s:3:"109";s:3:" di";s:3:"110";s:3:"ave";s:3:"111";s:3:"d h";s:3:"112";s:3:"cou";s:3:"113";s:3:"pro";s:3:"114";s:3:"ad ";s:3:"115";s:3:"oll";s:3:"116";s:3:"ry ";s:3:"117";s:3:"d s";s:3:"118";s:3:"e m";s:3:"119";s:3:" so";s:3:"120";s:3:"ill";s:3:"121";s:3:"cti";s:3:"122";s:3:"te ";s:3:"123";s:3:"tor";s:3:"124";s:3:"eve";s:3:"125";s:3:"g t";s:3:"126";s:3:"it ";s:3:"127";s:3:" ch";s:3:"128";s:3:" de";s:3:"129";s:3:"hav";s:3:"130";s:3:"oul";s:3:"131";s:3:"ty ";s:3:"132";s:3:"uld";s:3:"133";s:3:"use";s:3:"134";s:3:" al";s:3:"135";s:3:"are";s:3:"136";s:3:"ch ";s:3:"137";s:3:"me ";s:3:"138";s:3:"out";s:3:"139";s:3:"ove";s:3:"140";s:3:"wit";s:3:"141";s:3:"ys ";s:3:"142";s:3:"chi";s:3:"143";s:3:"t a";s:3:"144";s:3:"ith";s:3:"145";s:3:"oth";s:3:"146";s:3:" ab";s:3:"147";s:3:" te";s:3:"148";s:3:" wo";s:3:"149";s:3:"s s";s:3:"150";s:3:"res";s:3:"151";s:3:"t w";s:3:"152";s:3:"tin";s:3:"153";s:3:"e b";s:3:"154";s:3:"e h";s:3:"155";s:3:"nce";s:3:"156";s:3:"t s";s:3:"157";s:3:"y t";s:3:"158";s:3:"e p";s:3:"159";s:3:"ele";s:3:"160";s:3:"hin";s:3:"161";s:3:"s i";s:3:"162";s:3:"nte";s:3:"163";s:3:" li";s:3:"164";s:3:"le ";s:3:"165";s:3:" do";s:3:"166";s:3:"aid";s:3:"167";s:3:"hey";s:3:"168";s:3:"ne ";s:3:"169";s:3:"s w";s:3:"170";s:3:" as";s:3:"171";s:3:" fr";s:3:"172";s:3:" tr";s:3:"173";s:3:"end";s:3:"174";s:3:"sai";s:3:"175";s:3:" el";s:3:"176";s:3:" ne";s:3:"177";s:3:" su";s:3:"178";s:3:"'t ";s:3:"179";s:3:"ay ";s:3:"180";s:3:"hou";s:3:"181";s:3:"ive";s:3:"182";s:3:"lec";s:3:"183";s:3:"n't";s:3:"184";s:3:" ye";s:3:"185";s:3:"but";s:3:"186";s:3:"d o";s:3:"187";s:3:"o t";s:3:"188";s:3:"y o";s:3:"189";s:3:" ho";s:3:"190";s:3:" me";s:3:"191";s:3:"be ";s:3:"192";s:3:"cal";s:3:"193";s:3:"e e";s:3:"194";s:3:"had";s:3:"195";s:3:"ple";s:3:"196";s:3:" at";s:3:"197";s:3:" bu";s:3:"198";s:3:" la";s:3:"199";s:3:"d b";s:3:"200";s:3:"s h";s:3:"201";s:3:"say";s:3:"202";s:3:"t i";s:3:"203";s:3:" ar";s:3:"204";s:3:"e f";s:3:"205";s:3:"ght";s:3:"206";s:3:"hil";s:3:"207";s:3:"igh";s:3:"208";s:3:"int";s:3:"209";s:3:"not";s:3:"210";s:3:"ren";s:3:"211";s:3:" is";s:3:"212";s:3:" pa";s:3:"213";s:3:" sh";s:3:"214";s:3:"ays";s:3:"215";s:3:"com";s:3:"216";s:3:"n s";s:3:"217";s:3:"r a";s:3:"218";s:3:"rin";s:3:"219";s:3:"y a";s:3:"220";s:3:" un";s:3:"221";s:3:"n c";s:3:"222";s:3:"om ";s:3:"223";s:3:"thi";s:3:"224";s:3:" mi";s:3:"225";s:3:"by ";s:3:"226";s:3:"d i";s:3:"227";s:3:"e d";s:3:"228";s:3:"e n";s:3:"229";s:3:"t o";s:3:"230";s:3:" by";s:3:"231";s:3:"e r";s:3:"232";s:3:"eri";s:3:"233";s:3:"old";s:3:"234";s:3:"ome";s:3:"235";s:3:"whe";s:3:"236";s:3:"yea";s:3:"237";s:3:" gr";s:3:"238";s:3:"ar ";s:3:"239";s:3:"ity";s:3:"240";s:3:"mpl";s:3:"241";s:3:"oun";s:3:"242";s:3:"one";s:3:"243";s:3:"ow ";s:3:"244";s:3:"r s";s:3:"245";s:3:"s f";s:3:"246";s:3:"tat";s:3:"247";s:3:" ba";s:3:"248";s:3:" vo";s:3:"249";s:3:"bou";s:3:"250";s:3:"sam";s:3:"251";s:3:"tim";s:3:"252";s:3:"vot";s:3:"253";s:3:"abo";s:3:"254";s:3:"ant";s:3:"255";s:3:"ds ";s:3:"256";s:3:"ial";s:3:"257";s:3:"ine";s:3:"258";s:3:"man";s:3:"259";s:3:"men";s:3:"260";s:3:" or";s:3:"261";s:3:" po";s:3:"262";s:3:"amp";s:3:"263";s:3:"can";s:3:"264";s:3:"der";s:3:"265";s:3:"e l";s:3:"266";s:3:"les";s:3:"267";s:3:"ny ";s:3:"268";s:3:"ot ";s:3:"269";s:3:"rec";s:3:"270";s:3:"tes";s:3:"271";s:3:"tho";s:3:"272";s:3:"ica";s:3:"273";s:3:"ild";s:3:"274";s:3:"ir ";s:3:"275";s:3:"nde";s:3:"276";s:3:"ose";s:3:"277";s:3:"ous";s:3:"278";s:3:"pre";s:3:"279";s:3:"ste";s:3:"280";s:3:"era";s:3:"281";s:3:"per";s:3:"282";s:3:"r o";s:3:"283";s:3:"red";s:3:"284";s:3:"rie";s:3:"285";s:3:" bo";s:3:"286";s:3:" le";s:3:"287";s:3:"ali";s:3:"288";s:3:"ars";s:3:"289";s:3:"ore";s:3:"290";s:3:"ric";s:3:"291";s:3:"s m";s:3:"292";s:3:"str";s:3:"293";s:3:" fa";s:3:"294";s:3:"ess";s:3:"295";s:3:"ie ";s:3:"296";s:3:"ist";s:3:"297";s:3:"lat";s:3:"298";s:3:"uri";s:3:"299";}s:8:"estonian";a:300:{s:3:"st ";s:1:"0";s:3:" ka";s:1:"1";s:3:"on ";s:1:"2";s:3:"ja ";s:1:"3";s:3:" va";s:1:"4";s:3:" on";s:1:"5";s:3:" ja";s:1:"6";s:3:" ko";s:1:"7";s:3:"se ";s:1:"8";s:3:"ast";s:1:"9";s:3:"le ";s:2:"10";s:3:"es ";s:2:"11";s:3:"as ";s:2:"12";s:3:"is ";s:2:"13";s:3:"ud ";s:2:"14";s:3:" sa";s:2:"15";s:3:"da ";s:2:"16";s:3:"ga ";s:2:"17";s:3:" ta";s:2:"18";s:3:"aja";s:2:"19";s:3:"sta";s:2:"20";s:3:" ku";s:2:"21";s:3:" pe";s:2:"22";s:3:"a k";s:2:"23";s:3:"est";s:2:"24";s:3:"ist";s:2:"25";s:3:"ks ";s:2:"26";s:3:"ta ";s:2:"27";s:3:"al ";s:2:"28";s:3:"ava";s:2:"29";s:3:"id ";s:2:"30";s:3:"saa";s:2:"31";s:3:"mis";s:2:"32";s:3:"te ";s:2:"33";s:3:"val";s:2:"34";s:3:" et";s:2:"35";s:3:"nud";s:2:"36";s:3:" te";s:2:"37";s:3:"inn";s:2:"38";s:3:" se";s:2:"39";s:3:" tu";s:2:"40";s:3:"a v";s:2:"41";s:3:"alu";s:2:"42";s:3:"e k";s:2:"43";s:3:"ise";s:2:"44";s:3:"lu ";s:2:"45";s:3:"ma ";s:2:"46";s:3:"mes";s:2:"47";s:3:" mi";s:2:"48";s:3:"et ";s:2:"49";s:3:"iku";s:2:"50";s:3:"lin";s:2:"51";s:3:"ad ";s:2:"52";s:3:"el ";s:2:"53";s:3:"ime";s:2:"54";s:3:"ne ";s:2:"55";s:3:"nna";s:2:"56";s:3:" ha";s:2:"57";s:3:" in";s:2:"58";s:3:" ke";s:2:"59";s:4:" võ";s:2:"60";s:3:"a s";s:2:"61";s:3:"a t";s:2:"62";s:3:"ab ";s:2:"63";s:3:"e s";s:2:"64";s:3:"esi";s:2:"65";s:3:" la";s:2:"66";s:3:" li";s:2:"67";s:3:"e v";s:2:"68";s:3:"eks";s:2:"69";s:3:"ema";s:2:"70";s:3:"las";s:2:"71";s:3:"les";s:2:"72";s:3:"rju";s:2:"73";s:3:"tle";s:2:"74";s:3:"tsi";s:2:"75";s:3:"tus";s:2:"76";s:3:"upa";s:2:"77";s:3:"use";s:2:"78";s:3:"ust";s:2:"79";s:3:"var";s:2:"80";s:4:" lä";s:2:"81";s:3:"ali";s:2:"82";s:3:"arj";s:2:"83";s:3:"de ";s:2:"84";s:3:"ete";s:2:"85";s:3:"i t";s:2:"86";s:3:"iga";s:2:"87";s:3:"ilm";s:2:"88";s:3:"kui";s:2:"89";s:3:"li ";s:2:"90";s:3:"tul";s:2:"91";s:3:" ei";s:2:"92";s:3:" me";s:2:"93";s:4:" sõ";s:2:"94";s:3:"aal";s:2:"95";s:3:"ata";s:2:"96";s:3:"dus";s:2:"97";s:3:"ei ";s:2:"98";s:3:"nik";s:2:"99";s:3:"pea";s:3:"100";s:3:"s k";s:3:"101";s:3:"s o";s:3:"102";s:3:"sal";s:3:"103";s:4:"sõn";s:3:"104";s:3:"ter";s:3:"105";s:3:"ul ";s:3:"106";s:4:"või";s:3:"107";s:3:" el";s:3:"108";s:3:" ne";s:3:"109";s:3:"a j";s:3:"110";s:3:"ate";s:3:"111";s:3:"end";s:3:"112";s:3:"i k";s:3:"113";s:3:"ita";s:3:"114";s:3:"kar";s:3:"115";s:3:"kor";s:3:"116";s:3:"l o";s:3:"117";s:3:"lt ";s:3:"118";s:3:"maa";s:3:"119";s:3:"oli";s:3:"120";s:3:"sti";s:3:"121";s:3:"vad";s:3:"122";s:5:"ään";s:3:"123";s:3:" ju";s:3:"124";s:4:" jä";s:3:"125";s:4:" kü";s:3:"126";s:3:" ma";s:3:"127";s:3:" po";s:3:"128";s:4:" üt";s:3:"129";s:3:"aas";s:3:"130";s:3:"aks";s:3:"131";s:3:"at ";s:3:"132";s:3:"ed ";s:3:"133";s:3:"eri";s:3:"134";s:3:"hoi";s:3:"135";s:3:"i s";s:3:"136";s:3:"ka ";s:3:"137";s:3:"la ";s:3:"138";s:3:"nni";s:3:"139";s:3:"oid";s:3:"140";s:3:"pai";s:3:"141";s:3:"rit";s:3:"142";s:3:"us ";s:3:"143";s:4:"ütl";s:3:"144";s:3:" aa";s:3:"145";s:3:" lo";s:3:"146";s:3:" to";s:3:"147";s:3:" ve";s:3:"148";s:3:"a e";s:3:"149";s:3:"ada";s:3:"150";s:3:"aid";s:3:"151";s:3:"ami";s:3:"152";s:3:"and";s:3:"153";s:3:"dla";s:3:"154";s:3:"e j";s:3:"155";s:3:"ega";s:3:"156";s:3:"gi ";s:3:"157";s:3:"gu ";s:3:"158";s:3:"i p";s:3:"159";s:3:"idl";s:3:"160";s:3:"ik ";s:3:"161";s:3:"ini";s:3:"162";s:3:"jup";s:3:"163";s:3:"kal";s:3:"164";s:3:"kas";s:3:"165";s:3:"kes";s:3:"166";s:3:"koh";s:3:"167";s:3:"s e";s:3:"168";s:3:"s p";s:3:"169";s:3:"sel";s:3:"170";s:3:"sse";s:3:"171";s:3:"ui ";s:3:"172";s:3:" pi";s:3:"173";s:3:" si";s:3:"174";s:3:"aru";s:3:"175";s:3:"eda";s:3:"176";s:3:"eva";s:3:"177";s:3:"fil";s:3:"178";s:3:"i v";s:3:"179";s:3:"ida";s:3:"180";s:3:"ing";s:3:"181";s:5:"lää";s:3:"182";s:3:"me ";s:3:"183";s:3:"na ";s:3:"184";s:3:"nda";s:3:"185";s:3:"nim";s:3:"186";s:3:"ole";s:3:"187";s:3:"ots";s:3:"188";s:3:"ris";s:3:"189";s:3:"s l";s:3:"190";s:3:"sia";s:3:"191";s:3:"t p";s:3:"192";s:3:" en";s:3:"193";s:3:" mu";s:3:"194";s:3:" ol";s:3:"195";s:4:" põ";s:3:"196";s:3:" su";s:3:"197";s:4:" vä";s:3:"198";s:4:" üh";s:3:"199";s:3:"a l";s:3:"200";s:3:"a p";s:3:"201";s:3:"aga";s:3:"202";s:3:"ale";s:3:"203";s:3:"aps";s:3:"204";s:3:"arv";s:3:"205";s:3:"e a";s:3:"206";s:3:"ela";s:3:"207";s:3:"ika";s:3:"208";s:3:"lle";s:3:"209";s:3:"loo";s:3:"210";s:3:"mal";s:3:"211";s:3:"pet";s:3:"212";s:3:"t k";s:3:"213";s:3:"tee";s:3:"214";s:3:"tis";s:3:"215";s:3:"vat";s:3:"216";s:4:"äne";s:3:"217";s:4:"õnn";s:3:"218";s:3:" es";s:3:"219";s:3:" fi";s:3:"220";s:3:" vi";s:3:"221";s:3:"a i";s:3:"222";s:3:"a o";s:3:"223";s:3:"aab";s:3:"224";s:3:"aap";s:3:"225";s:3:"ala";s:3:"226";s:3:"alt";s:3:"227";s:3:"ama";s:3:"228";s:3:"anu";s:3:"229";s:3:"e p";s:3:"230";s:3:"e t";s:3:"231";s:3:"eal";s:3:"232";s:3:"eli";s:3:"233";s:3:"haa";s:3:"234";s:3:"hin";s:3:"235";s:3:"iva";s:3:"236";s:3:"kon";s:3:"237";s:3:"ku ";s:3:"238";s:3:"lik";s:3:"239";s:3:"lm ";s:3:"240";s:3:"min";s:3:"241";s:3:"n t";s:3:"242";s:3:"odu";s:3:"243";s:3:"oon";s:3:"244";s:3:"psa";s:3:"245";s:3:"ri ";s:3:"246";s:3:"si ";s:3:"247";s:3:"stu";s:3:"248";s:3:"t e";s:3:"249";s:3:"t s";s:3:"250";s:3:"ti ";s:3:"251";s:3:"ule";s:3:"252";s:3:"uur";s:3:"253";s:3:"vas";s:3:"254";s:3:"vee";s:3:"255";s:3:" ki";s:3:"256";s:3:" ni";s:3:"257";s:4:" nä";s:3:"258";s:3:" ra";s:3:"259";s:3:"aig";s:3:"260";s:3:"aka";s:3:"261";s:3:"all";s:3:"262";s:3:"atu";s:3:"263";s:3:"e e";s:3:"264";s:3:"eis";s:3:"265";s:3:"ers";s:3:"266";s:3:"i e";s:3:"267";s:3:"ii ";s:3:"268";s:3:"iis";s:3:"269";s:3:"il ";s:3:"270";s:3:"ima";s:3:"271";s:3:"its";s:3:"272";s:3:"kka";s:3:"273";s:3:"kuh";s:3:"274";s:3:"l k";s:3:"275";s:3:"lat";s:3:"276";s:3:"maj";s:3:"277";s:3:"ndu";s:3:"278";s:3:"ni ";s:3:"279";s:3:"nii";s:3:"280";s:3:"oma";s:3:"281";s:3:"ool";s:3:"282";s:3:"rso";s:3:"283";s:3:"ru ";s:3:"284";s:3:"rva";s:3:"285";s:3:"s t";s:3:"286";s:3:"sek";s:3:"287";s:3:"son";s:3:"288";s:3:"ste";s:3:"289";s:3:"t m";s:3:"290";s:3:"taj";s:3:"291";s:3:"tam";s:3:"292";s:3:"ude";s:3:"293";s:3:"uho";s:3:"294";s:3:"vai";s:3:"295";s:3:" ag";s:3:"296";s:3:" os";s:3:"297";s:3:" pa";s:3:"298";s:3:" re";s:3:"299";}s:5:"farsi";a:300:{s:5:"ان ";s:1:"0";s:5:"ای ";s:1:"1";s:5:"ه ا";s:1:"2";s:5:" اي";s:1:"3";s:5:" در";s:1:"4";s:5:"به ";s:1:"5";s:5:" بر";s:1:"6";s:5:"در ";s:1:"7";s:6:"ران";s:1:"8";s:5:" به";s:1:"9";s:5:"ی ا";s:2:"10";s:5:"از ";s:2:"11";s:5:"ين ";s:2:"12";s:5:"می ";s:2:"13";s:5:" از";s:2:"14";s:5:"ده ";s:2:"15";s:5:"ست ";s:2:"16";s:6:"است";s:2:"17";s:5:" اس";s:2:"18";s:5:" که";s:2:"19";s:5:"که ";s:2:"20";s:6:"اير";s:2:"21";s:5:"ند ";s:2:"22";s:6:"اين";s:2:"23";s:5:" ها";s:2:"24";s:6:"يرا";s:2:"25";s:5:"ود ";s:2:"26";s:5:" را";s:2:"27";s:6:"های";s:2:"28";s:5:" خو";s:2:"29";s:5:"ته ";s:2:"30";s:5:"را ";s:2:"31";s:6:"رای";s:2:"32";s:5:"رد ";s:2:"33";s:5:"ن ب";s:2:"34";s:6:"کرد";s:2:"35";s:4:" و ";s:2:"36";s:5:" کر";s:2:"37";s:5:"ات ";s:2:"38";s:6:"برا";s:2:"39";s:5:"د ک";s:2:"40";s:6:"مان";s:2:"41";s:5:"ی د";s:2:"42";s:5:" ان";s:2:"43";s:6:"خوا";s:2:"44";s:6:"شور";s:2:"45";s:5:" با";s:2:"46";s:5:"ن ا";s:2:"47";s:5:" سا";s:2:"48";s:6:"تمی";s:2:"49";s:5:"ری ";s:2:"50";s:6:"اتم";s:2:"51";s:5:"ا ا";s:2:"52";s:6:"واه";s:2:"53";s:5:" ات";s:2:"54";s:5:" عر";s:2:"55";s:5:"اق ";s:2:"56";s:5:"ر م";s:2:"57";s:6:"راق";s:2:"58";s:6:"عرا";s:2:"59";s:5:"ی ب";s:2:"60";s:5:" تا";s:2:"61";s:5:" تو";s:2:"62";s:5:"ار ";s:2:"63";s:5:"ر ا";s:2:"64";s:5:"ن م";s:2:"65";s:5:"ه ب";s:2:"66";s:5:"ور ";s:2:"67";s:5:"يد ";s:2:"68";s:5:"ی ک";s:2:"69";s:5:" ام";s:2:"70";s:5:" دا";s:2:"71";s:5:" کن";s:2:"72";s:6:"اهد";s:2:"73";s:5:"هد ";s:2:"74";s:5:" آن";s:2:"75";s:5:" می";s:2:"76";s:5:" ني";s:2:"77";s:5:" گف";s:2:"78";s:5:"د ا";s:2:"79";s:6:"گفت";s:2:"80";s:5:" کش";s:2:"81";s:5:"ا ب";s:2:"82";s:5:"نی ";s:2:"83";s:5:"ها ";s:2:"84";s:6:"کشو";s:2:"85";s:5:" رو";s:2:"86";s:5:"ت ک";s:2:"87";s:6:"نيو";s:2:"88";s:5:"ه م";s:2:"89";s:5:"وی ";s:2:"90";s:5:"ی ت";s:2:"91";s:5:" شو";s:2:"92";s:5:"ال ";s:2:"93";s:6:"دار";s:2:"94";s:5:"مه ";s:2:"95";s:5:"ن ک";s:2:"96";s:5:"ه د";s:2:"97";s:5:"يه ";s:2:"98";s:5:" ما";s:2:"99";s:6:"امه";s:3:"100";s:5:"د ب";s:3:"101";s:6:"زار";s:3:"102";s:6:"ورا";s:3:"103";s:6:"گزا";s:3:"104";s:5:" پي";s:3:"105";s:5:"آن ";s:3:"106";s:6:"انت";s:3:"107";s:5:"ت ا";s:3:"108";s:5:"فت ";s:3:"109";s:5:"ه ن";s:3:"110";s:5:"ی خ";s:3:"111";s:6:"اما";s:3:"112";s:6:"بات";s:3:"113";s:5:"ما ";s:3:"114";s:6:"ملل";s:3:"115";s:6:"نام";s:3:"116";s:5:"ير ";s:3:"117";s:5:"ی م";s:3:"118";s:5:"ی ه";s:3:"119";s:5:" آم";s:3:"120";s:5:" ای";s:3:"121";s:5:" من";s:3:"122";s:6:"انس";s:3:"123";s:6:"اني";s:3:"124";s:5:"ت د";s:3:"125";s:6:"رده";s:3:"126";s:6:"ساز";s:3:"127";s:5:"ن د";s:3:"128";s:5:"نه ";s:3:"129";s:6:"ورد";s:3:"130";s:5:" او";s:3:"131";s:5:" بي";s:3:"132";s:5:" سو";s:3:"133";s:5:" شد";s:3:"134";s:6:"اده";s:3:"135";s:6:"اند";s:3:"136";s:5:"با ";s:3:"137";s:5:"ت ب";s:3:"138";s:5:"ر ب";s:3:"139";s:5:"ز ا";s:3:"140";s:6:"زما";s:3:"141";s:6:"سته";s:3:"142";s:5:"ن ر";s:3:"143";s:5:"ه س";s:3:"144";s:6:"وان";s:3:"145";s:5:"وز ";s:3:"146";s:5:"ی ر";s:3:"147";s:5:"ی س";s:3:"148";s:5:" هس";s:3:"149";s:6:"ابا";s:3:"150";s:5:"ام ";s:3:"151";s:6:"اور";s:3:"152";s:6:"تخا";s:3:"153";s:6:"خاب";s:3:"154";s:6:"خود";s:3:"155";s:5:"د د";s:3:"156";s:5:"دن ";s:3:"157";s:6:"رها";s:3:"158";s:6:"روز";s:3:"159";s:6:"رگز";s:3:"160";s:6:"نتخ";s:3:"161";s:5:"ه ش";s:3:"162";s:5:"ه ه";s:3:"163";s:6:"هست";s:3:"164";s:5:"يت ";s:3:"165";s:5:"يم ";s:3:"166";s:5:" دو";s:3:"167";s:5:" دي";s:3:"168";s:5:" مو";s:3:"169";s:5:" نو";s:3:"170";s:5:" هم";s:3:"171";s:5:" کا";s:3:"172";s:5:"اد ";s:3:"173";s:6:"اری";s:3:"174";s:6:"انی";s:3:"175";s:5:"بر ";s:3:"176";s:6:"بود";s:3:"177";s:5:"ت ه";s:3:"178";s:5:"ح ه";s:3:"179";s:6:"حال";s:3:"180";s:5:"رش ";s:3:"181";s:5:"عه ";s:3:"182";s:5:"لی ";s:3:"183";s:5:"وم ";s:3:"184";s:6:"ژان";s:3:"185";s:5:" سل";s:3:"186";s:6:"آمر";s:3:"187";s:5:"اح ";s:3:"188";s:6:"توس";s:3:"189";s:6:"داد";s:3:"190";s:6:"دام";s:3:"191";s:5:"ر د";s:3:"192";s:5:"ره ";s:3:"193";s:6:"ريک";s:3:"194";s:5:"زی ";s:3:"195";s:6:"سلا";s:3:"196";s:6:"شود";s:3:"197";s:6:"لاح";s:3:"198";s:6:"مري";s:3:"199";s:6:"نند";s:3:"200";s:5:"ه ع";s:3:"201";s:6:"يما";s:3:"202";s:6:"يکا";s:3:"203";s:6:"پيم";s:3:"204";s:5:"گر ";s:3:"205";s:5:" آژ";s:3:"206";s:5:" ال";s:3:"207";s:5:" بو";s:3:"208";s:5:" مق";s:3:"209";s:5:" مل";s:3:"210";s:5:" وی";s:3:"211";s:6:"آژا";s:3:"212";s:6:"ازم";s:3:"213";s:6:"ازی";s:3:"214";s:6:"بار";s:3:"215";s:6:"برن";s:3:"216";s:5:"ر آ";s:3:"217";s:5:"ز س";s:3:"218";s:6:"سعه";s:3:"219";s:6:"شته";s:3:"220";s:6:"مات";s:3:"221";s:5:"ن آ";s:3:"222";s:5:"ن پ";s:3:"223";s:5:"نس ";s:3:"224";s:5:"ه گ";s:3:"225";s:6:"وسع";s:3:"226";s:6:"يان";s:3:"227";s:6:"يوم";s:3:"228";s:5:"کا ";s:3:"229";s:6:"کام";s:3:"230";s:6:"کند";s:3:"231";s:5:" خا";s:3:"232";s:5:" سر";s:3:"233";s:6:"آور";s:3:"234";s:6:"ارد";s:3:"235";s:6:"اقد";s:3:"236";s:6:"ايم";s:3:"237";s:6:"ايی";s:3:"238";s:6:"برگ";s:3:"239";s:5:"ت ع";s:3:"240";s:5:"تن ";s:3:"241";s:5:"خت ";s:3:"242";s:5:"د و";s:3:"243";s:5:"ر خ";s:3:"244";s:5:"رک ";s:3:"245";s:6:"زير";s:3:"246";s:6:"فته";s:3:"247";s:6:"قدا";s:3:"248";s:5:"ل ت";s:3:"249";s:6:"مين";s:3:"250";s:5:"ن گ";s:3:"251";s:5:"ه آ";s:3:"252";s:5:"ه خ";s:3:"253";s:5:"ه ک";s:3:"254";s:6:"ورک";s:3:"255";s:6:"ويو";s:3:"256";s:6:"يور";s:3:"257";s:6:"يوي";s:3:"258";s:5:"يی ";s:3:"259";s:5:"ک ت";s:3:"260";s:5:"ی ش";s:3:"261";s:5:" اق";s:3:"262";s:5:" حا";s:3:"263";s:5:" حق";s:3:"264";s:5:" دس";s:3:"265";s:5:" شک";s:3:"266";s:5:" عم";s:3:"267";s:5:" يک";s:3:"268";s:5:"ا ت";s:3:"269";s:5:"ا د";s:3:"270";s:6:"ارج";s:3:"271";s:6:"بين";s:3:"272";s:5:"ت م";s:3:"273";s:5:"ت و";s:3:"274";s:6:"تاي";s:3:"275";s:6:"دست";s:3:"276";s:5:"ر ح";s:3:"277";s:5:"ر س";s:3:"278";s:6:"رنا";s:3:"279";s:5:"ز ب";s:3:"280";s:6:"شکا";s:3:"281";s:5:"لل ";s:3:"282";s:5:"م ک";s:3:"283";s:5:"مز ";s:3:"284";s:6:"ندا";s:3:"285";s:6:"نوا";s:3:"286";s:5:"و ا";s:3:"287";s:6:"وره";s:3:"288";s:5:"ون ";s:3:"289";s:6:"وند";s:3:"290";s:6:"يمز";s:3:"291";s:5:" آو";s:3:"292";s:5:" اع";s:3:"293";s:5:" فر";s:3:"294";s:5:" مت";s:3:"295";s:5:" نه";s:3:"296";s:5:" هر";s:3:"297";s:5:" وز";s:3:"298";s:5:" گز";s:3:"299";}s:7:"finnish";a:300:{s:3:"en ";s:1:"0";s:3:"in ";s:1:"1";s:3:"an ";s:1:"2";s:3:"on ";s:1:"3";s:3:"ist";s:1:"4";s:3:"ta ";s:1:"5";s:3:"ja ";s:1:"6";s:3:"n t";s:1:"7";s:3:"sa ";s:1:"8";s:3:"sta";s:1:"9";s:3:"aan";s:2:"10";s:3:"n p";s:2:"11";s:3:" on";s:2:"12";s:3:"ssa";s:2:"13";s:3:"tta";s:2:"14";s:4:"tä ";s:2:"15";s:3:" ka";s:2:"16";s:3:" pa";s:2:"17";s:3:"si ";s:2:"18";s:3:" ja";s:2:"19";s:3:"n k";s:2:"20";s:3:"lla";s:2:"21";s:4:"än ";s:2:"22";s:3:"een";s:2:"23";s:3:"n v";s:2:"24";s:3:"ksi";s:2:"25";s:3:"ett";s:2:"26";s:3:"nen";s:2:"27";s:3:"taa";s:2:"28";s:4:"ttä";s:2:"29";s:3:" va";s:2:"30";s:3:"ill";s:2:"31";s:3:"itt";s:2:"32";s:3:" jo";s:2:"33";s:3:" ko";s:2:"34";s:3:"n s";s:2:"35";s:3:" tu";s:2:"36";s:3:"ia ";s:2:"37";s:3:" su";s:2:"38";s:3:"a p";s:2:"39";s:3:"aa ";s:2:"40";s:3:"la ";s:2:"41";s:3:"lle";s:2:"42";s:3:"n m";s:2:"43";s:3:"le ";s:2:"44";s:3:"tte";s:2:"45";s:3:"na ";s:2:"46";s:3:" ta";s:2:"47";s:3:" ve";s:2:"48";s:3:"at ";s:2:"49";s:3:" vi";s:2:"50";s:3:"utt";s:2:"51";s:3:" sa";s:2:"52";s:3:"ise";s:2:"53";s:3:"sen";s:2:"54";s:3:" ku";s:2:"55";s:4:" nä";s:2:"56";s:4:" pä";s:2:"57";s:3:"ste";s:2:"58";s:3:" ol";s:2:"59";s:3:"a t";s:2:"60";s:3:"ais";s:2:"61";s:3:"maa";s:2:"62";s:3:"ti ";s:2:"63";s:3:"a o";s:2:"64";s:3:"oit";s:2:"65";s:5:"pää";s:2:"66";s:3:" pi";s:2:"67";s:3:"a v";s:2:"68";s:3:"ala";s:2:"69";s:3:"ine";s:2:"70";s:3:"isi";s:2:"71";s:3:"tel";s:2:"72";s:3:"tti";s:2:"73";s:3:" si";s:2:"74";s:3:"a k";s:2:"75";s:3:"all";s:2:"76";s:3:"iin";s:2:"77";s:3:"kin";s:2:"78";s:4:"stä";s:2:"79";s:3:"uom";s:2:"80";s:3:"vii";s:2:"81";s:3:" ma";s:2:"82";s:3:" se";s:2:"83";s:4:"enä";s:2:"84";s:3:" mu";s:2:"85";s:3:"a s";s:2:"86";s:3:"est";s:2:"87";s:3:"iss";s:2:"88";s:4:"llä";s:2:"89";s:3:"lok";s:2:"90";s:4:"lä ";s:2:"91";s:3:"n j";s:2:"92";s:3:"n o";s:2:"93";s:3:"toi";s:2:"94";s:3:"ven";s:2:"95";s:3:"ytt";s:2:"96";s:3:" li";s:2:"97";s:3:"ain";s:2:"98";s:3:"et ";s:2:"99";s:3:"ina";s:3:"100";s:3:"n a";s:3:"101";s:3:"n n";s:3:"102";s:3:"oll";s:3:"103";s:3:"plo";s:3:"104";s:3:"ten";s:3:"105";s:3:"ust";s:3:"106";s:4:"äll";s:3:"107";s:5:"ään";s:3:"108";s:3:" to";s:3:"109";s:3:"den";s:3:"110";s:3:"men";s:3:"111";s:3:"oki";s:3:"112";s:3:"suo";s:3:"113";s:4:"sä ";s:3:"114";s:5:"tää";s:3:"115";s:3:"uks";s:3:"116";s:3:"vat";s:3:"117";s:3:" al";s:3:"118";s:3:" ke";s:3:"119";s:3:" te";s:3:"120";s:3:"a e";s:3:"121";s:3:"lii";s:3:"122";s:3:"tai";s:3:"123";s:3:"tei";s:3:"124";s:4:"äis";s:3:"125";s:5:"ää ";s:3:"126";s:3:" pl";s:3:"127";s:3:"ell";s:3:"128";s:3:"i t";s:3:"129";s:3:"ide";s:3:"130";s:3:"ikk";s:3:"131";s:3:"ki ";s:3:"132";s:3:"nta";s:3:"133";s:3:"ova";s:3:"134";s:3:"yst";s:3:"135";s:3:"yt ";s:3:"136";s:4:"ä p";s:3:"137";s:4:"äyt";s:3:"138";s:3:" ha";s:3:"139";s:3:" pe";s:3:"140";s:4:" tä";s:3:"141";s:3:"a n";s:3:"142";s:3:"aik";s:3:"143";s:3:"i p";s:3:"144";s:3:"i v";s:3:"145";s:3:"nyt";s:3:"146";s:4:"näy";s:3:"147";s:3:"pal";s:3:"148";s:3:"tee";s:3:"149";s:3:"un ";s:3:"150";s:3:" me";s:3:"151";s:3:"a m";s:3:"152";s:3:"ess";s:3:"153";s:3:"kau";s:3:"154";s:3:"pai";s:3:"155";s:3:"stu";s:3:"156";s:3:"ut ";s:3:"157";s:3:"voi";s:3:"158";s:3:" et";s:3:"159";s:3:"a h";s:3:"160";s:3:"eis";s:3:"161";s:3:"hte";s:3:"162";s:3:"i o";s:3:"163";s:3:"iik";s:3:"164";s:3:"ita";s:3:"165";s:3:"jou";s:3:"166";s:3:"mis";s:3:"167";s:3:"nin";s:3:"168";s:3:"nut";s:3:"169";s:3:"sia";s:3:"170";s:4:"ssä";s:3:"171";s:3:"van";s:3:"172";s:3:" ty";s:3:"173";s:3:" yh";s:3:"174";s:3:"aks";s:3:"175";s:3:"ime";s:3:"176";s:3:"loi";s:3:"177";s:3:"me ";s:3:"178";s:3:"n e";s:3:"179";s:3:"n h";s:3:"180";s:3:"n l";s:3:"181";s:3:"oin";s:3:"182";s:3:"ome";s:3:"183";s:3:"ott";s:3:"184";s:3:"ouk";s:3:"185";s:3:"sit";s:3:"186";s:3:"sti";s:3:"187";s:3:"tet";s:3:"188";s:3:"tie";s:3:"189";s:3:"ukk";s:3:"190";s:4:"ä k";s:3:"191";s:3:" ra";s:3:"192";s:3:" ti";s:3:"193";s:3:"aja";s:3:"194";s:3:"asi";s:3:"195";s:3:"ent";s:3:"196";s:3:"iga";s:3:"197";s:3:"iig";s:3:"198";s:3:"ite";s:3:"199";s:3:"jan";s:3:"200";s:3:"kaa";s:3:"201";s:3:"kse";s:3:"202";s:3:"laa";s:3:"203";s:3:"lan";s:3:"204";s:3:"li ";s:3:"205";s:4:"näj";s:3:"206";s:3:"ole";s:3:"207";s:3:"tii";s:3:"208";s:3:"usi";s:3:"209";s:5:"äjä";s:3:"210";s:3:" ov";s:3:"211";s:3:"a a";s:3:"212";s:3:"ant";s:3:"213";s:3:"ava";s:3:"214";s:3:"ei ";s:3:"215";s:3:"eri";s:3:"216";s:3:"kan";s:3:"217";s:3:"kku";s:3:"218";s:3:"lai";s:3:"219";s:3:"lis";s:3:"220";s:4:"läi";s:3:"221";s:3:"mat";s:3:"222";s:3:"ois";s:3:"223";s:3:"pel";s:3:"224";s:3:"sil";s:3:"225";s:3:"sty";s:3:"226";s:3:"taj";s:3:"227";s:3:"tav";s:3:"228";s:3:"ttu";s:3:"229";s:4:"työ";s:3:"230";s:4:"yös";s:3:"231";s:4:"ä o";s:3:"232";s:3:" ai";s:3:"233";s:3:" pu";s:3:"234";s:3:"a j";s:3:"235";s:3:"a l";s:3:"236";s:3:"aal";s:3:"237";s:3:"arv";s:3:"238";s:3:"ass";s:3:"239";s:3:"ien";s:3:"240";s:3:"imi";s:3:"241";s:3:"imm";s:3:"242";s:4:"itä";s:3:"243";s:3:"ka ";s:3:"244";s:3:"kes";s:3:"245";s:3:"kue";s:3:"246";s:3:"lee";s:3:"247";s:3:"lin";s:3:"248";s:3:"llo";s:3:"249";s:3:"one";s:3:"250";s:3:"ri ";s:3:"251";s:3:"t o";s:3:"252";s:3:"t p";s:3:"253";s:3:"tu ";s:3:"254";s:3:"val";s:3:"255";s:3:"vuo";s:3:"256";s:3:" ei";s:3:"257";s:3:" he";s:3:"258";s:3:" hy";s:3:"259";s:3:" my";s:3:"260";s:3:" vo";s:3:"261";s:3:"ali";s:3:"262";s:3:"alo";s:3:"263";s:3:"ano";s:3:"264";s:3:"ast";s:3:"265";s:3:"att";s:3:"266";s:3:"auk";s:3:"267";s:3:"eli";s:3:"268";s:3:"ely";s:3:"269";s:3:"hti";s:3:"270";s:3:"ika";s:3:"271";s:3:"ken";s:3:"272";s:3:"kki";s:3:"273";s:3:"lys";s:3:"274";s:3:"min";s:3:"275";s:4:"myö";s:3:"276";s:3:"oht";s:3:"277";s:3:"oma";s:3:"278";s:3:"tus";s:3:"279";s:3:"umi";s:3:"280";s:3:"yks";s:3:"281";s:4:"ät ";s:3:"282";s:5:"ääl";s:3:"283";s:4:"ös ";s:3:"284";s:3:" ar";s:3:"285";s:3:" eu";s:3:"286";s:3:" hu";s:3:"287";s:3:" na";s:3:"288";s:3:"aat";s:3:"289";s:3:"alk";s:3:"290";s:3:"alu";s:3:"291";s:3:"ans";s:3:"292";s:3:"arj";s:3:"293";s:3:"enn";s:3:"294";s:3:"han";s:3:"295";s:3:"kuu";s:3:"296";s:3:"n y";s:3:"297";s:3:"set";s:3:"298";s:3:"sim";s:3:"299";}s:6:"french";a:300:{s:3:"es ";s:1:"0";s:3:" de";s:1:"1";s:3:"de ";s:1:"2";s:3:" le";s:1:"3";s:3:"ent";s:1:"4";s:3:"le ";s:1:"5";s:3:"nt ";s:1:"6";s:3:"la ";s:1:"7";s:3:"s d";s:1:"8";s:3:" la";s:1:"9";s:3:"ion";s:2:"10";s:3:"on ";s:2:"11";s:3:"re ";s:2:"12";s:3:" pa";s:2:"13";s:3:"e l";s:2:"14";s:3:"e d";s:2:"15";s:3:" l'";s:2:"16";s:3:"e p";s:2:"17";s:3:" co";s:2:"18";s:3:" pr";s:2:"19";s:3:"tio";s:2:"20";s:3:"ns ";s:2:"21";s:3:" en";s:2:"22";s:3:"ne ";s:2:"23";s:3:"que";s:2:"24";s:3:"r l";s:2:"25";s:3:"les";s:2:"26";s:3:"ur ";s:2:"27";s:3:"en ";s:2:"28";s:3:"ati";s:2:"29";s:3:"ue ";s:2:"30";s:3:" po";s:2:"31";s:3:" d'";s:2:"32";s:3:"par";s:2:"33";s:3:" a ";s:2:"34";s:3:"et ";s:2:"35";s:3:"it ";s:2:"36";s:3:" qu";s:2:"37";s:3:"men";s:2:"38";s:3:"ons";s:2:"39";s:3:"te ";s:2:"40";s:3:" et";s:2:"41";s:3:"t d";s:2:"42";s:3:" re";s:2:"43";s:3:"des";s:2:"44";s:3:" un";s:2:"45";s:3:"ie ";s:2:"46";s:3:"s l";s:2:"47";s:3:" su";s:2:"48";s:3:"pou";s:2:"49";s:3:" au";s:2:"50";s:4:" à ";s:2:"51";s:3:"con";s:2:"52";s:3:"er ";s:2:"53";s:3:" no";s:2:"54";s:3:"ait";s:2:"55";s:3:"e c";s:2:"56";s:3:"se ";s:2:"57";s:4:"té ";s:2:"58";s:3:"du ";s:2:"59";s:3:" du";s:2:"60";s:4:" dé";s:2:"61";s:3:"ce ";s:2:"62";s:3:"e e";s:2:"63";s:3:"is ";s:2:"64";s:3:"n d";s:2:"65";s:3:"s a";s:2:"66";s:3:" so";s:2:"67";s:3:"e r";s:2:"68";s:3:"e s";s:2:"69";s:3:"our";s:2:"70";s:3:"res";s:2:"71";s:3:"ssi";s:2:"72";s:3:"eur";s:2:"73";s:3:" se";s:2:"74";s:3:"eme";s:2:"75";s:3:"est";s:2:"76";s:3:"us ";s:2:"77";s:3:"sur";s:2:"78";s:3:"ant";s:2:"79";s:3:"iqu";s:2:"80";s:3:"s p";s:2:"81";s:3:"une";s:2:"82";s:3:"uss";s:2:"83";s:3:"l'a";s:2:"84";s:3:"pro";s:2:"85";s:3:"ter";s:2:"86";s:3:"tre";s:2:"87";s:3:"end";s:2:"88";s:3:"rs ";s:2:"89";s:3:" ce";s:2:"90";s:3:"e a";s:2:"91";s:3:"t p";s:2:"92";s:3:"un ";s:2:"93";s:3:" ma";s:2:"94";s:3:" ru";s:2:"95";s:4:" ré";s:2:"96";s:3:"ous";s:2:"97";s:3:"ris";s:2:"98";s:3:"rus";s:2:"99";s:3:"sse";s:3:"100";s:3:"ans";s:3:"101";s:3:"ar ";s:3:"102";s:3:"com";s:3:"103";s:3:"e m";s:3:"104";s:3:"ire";s:3:"105";s:3:"nce";s:3:"106";s:3:"nte";s:3:"107";s:3:"t l";s:3:"108";s:3:" av";s:3:"109";s:3:" mo";s:3:"110";s:3:" te";s:3:"111";s:3:"il ";s:3:"112";s:3:"me ";s:3:"113";s:3:"ont";s:3:"114";s:3:"ten";s:3:"115";s:3:"a p";s:3:"116";s:3:"dan";s:3:"117";s:3:"pas";s:3:"118";s:3:"qui";s:3:"119";s:3:"s e";s:3:"120";s:3:"s s";s:3:"121";s:3:" in";s:3:"122";s:3:"ist";s:3:"123";s:3:"lle";s:3:"124";s:3:"nou";s:3:"125";s:4:"pré";s:3:"126";s:3:"'un";s:3:"127";s:3:"air";s:3:"128";s:3:"d'a";s:3:"129";s:3:"ir ";s:3:"130";s:3:"n e";s:3:"131";s:3:"rop";s:3:"132";s:3:"ts ";s:3:"133";s:3:" da";s:3:"134";s:3:"a s";s:3:"135";s:3:"as ";s:3:"136";s:3:"au ";s:3:"137";s:3:"den";s:3:"138";s:3:"mai";s:3:"139";s:3:"mis";s:3:"140";s:3:"ori";s:3:"141";s:3:"out";s:3:"142";s:3:"rme";s:3:"143";s:3:"sio";s:3:"144";s:3:"tte";s:3:"145";s:3:"ux ";s:3:"146";s:3:"a d";s:3:"147";s:3:"ien";s:3:"148";s:3:"n a";s:3:"149";s:3:"ntr";s:3:"150";s:3:"omm";s:3:"151";s:3:"ort";s:3:"152";s:3:"ouv";s:3:"153";s:3:"s c";s:3:"154";s:3:"son";s:3:"155";s:3:"tes";s:3:"156";s:3:"ver";s:3:"157";s:4:"ère";s:3:"158";s:3:" il";s:3:"159";s:3:" m ";s:3:"160";s:3:" sa";s:3:"161";s:3:" ve";s:3:"162";s:3:"a r";s:3:"163";s:3:"ais";s:3:"164";s:3:"ava";s:3:"165";s:3:"di ";s:3:"166";s:3:"n p";s:3:"167";s:3:"sti";s:3:"168";s:3:"ven";s:3:"169";s:3:" mi";s:3:"170";s:3:"ain";s:3:"171";s:3:"enc";s:3:"172";s:3:"for";s:3:"173";s:4:"ité";s:3:"174";s:3:"lar";s:3:"175";s:3:"oir";s:3:"176";s:3:"rem";s:3:"177";s:3:"ren";s:3:"178";s:3:"rro";s:3:"179";s:4:"rés";s:3:"180";s:3:"sie";s:3:"181";s:3:"t a";s:3:"182";s:3:"tur";s:3:"183";s:3:" pe";s:3:"184";s:3:" to";s:3:"185";s:3:"d'u";s:3:"186";s:3:"ell";s:3:"187";s:3:"err";s:3:"188";s:3:"ers";s:3:"189";s:3:"ide";s:3:"190";s:3:"ine";s:3:"191";s:3:"iss";s:3:"192";s:3:"mes";s:3:"193";s:3:"por";s:3:"194";s:3:"ran";s:3:"195";s:3:"sit";s:3:"196";s:3:"st ";s:3:"197";s:3:"t r";s:3:"198";s:3:"uti";s:3:"199";s:3:"vai";s:3:"200";s:4:"é l";s:3:"201";s:4:"ési";s:3:"202";s:3:" di";s:3:"203";s:3:" n'";s:3:"204";s:4:" ét";s:3:"205";s:3:"a c";s:3:"206";s:3:"ass";s:3:"207";s:3:"e t";s:3:"208";s:3:"in ";s:3:"209";s:3:"nde";s:3:"210";s:3:"pre";s:3:"211";s:3:"rat";s:3:"212";s:3:"s m";s:3:"213";s:3:"ste";s:3:"214";s:3:"tai";s:3:"215";s:3:"tch";s:3:"216";s:3:"ui ";s:3:"217";s:3:"uro";s:3:"218";s:4:"ès ";s:3:"219";s:3:" es";s:3:"220";s:3:" fo";s:3:"221";s:3:" tr";s:3:"222";s:3:"'ad";s:3:"223";s:3:"app";s:3:"224";s:3:"aux";s:3:"225";s:4:"e à";s:3:"226";s:3:"ett";s:3:"227";s:3:"iti";s:3:"228";s:3:"lit";s:3:"229";s:3:"nal";s:3:"230";s:4:"opé";s:3:"231";s:3:"r d";s:3:"232";s:3:"ra ";s:3:"233";s:3:"rai";s:3:"234";s:3:"ror";s:3:"235";s:3:"s r";s:3:"236";s:3:"tat";s:3:"237";s:4:"uté";s:3:"238";s:4:"à l";s:3:"239";s:3:" af";s:3:"240";s:3:"anc";s:3:"241";s:3:"ara";s:3:"242";s:3:"art";s:3:"243";s:3:"bre";s:3:"244";s:4:"ché";s:3:"245";s:3:"dre";s:3:"246";s:3:"e f";s:3:"247";s:3:"ens";s:3:"248";s:3:"lem";s:3:"249";s:3:"n r";s:3:"250";s:3:"n t";s:3:"251";s:3:"ndr";s:3:"252";s:3:"nne";s:3:"253";s:3:"onn";s:3:"254";s:3:"pos";s:3:"255";s:3:"s t";s:3:"256";s:3:"tiq";s:3:"257";s:3:"ure";s:3:"258";s:3:" tu";s:3:"259";s:3:"ale";s:3:"260";s:3:"and";s:3:"261";s:3:"ave";s:3:"262";s:3:"cla";s:3:"263";s:3:"cou";s:3:"264";s:3:"e n";s:3:"265";s:3:"emb";s:3:"266";s:3:"ins";s:3:"267";s:3:"jou";s:3:"268";s:3:"mme";s:3:"269";s:3:"rie";s:3:"270";s:4:"rès";s:3:"271";s:3:"sem";s:3:"272";s:3:"str";s:3:"273";s:3:"t i";s:3:"274";s:3:"ues";s:3:"275";s:3:"uni";s:3:"276";s:3:"uve";s:3:"277";s:4:"é d";s:3:"278";s:4:"ée ";s:3:"279";s:3:" ch";s:3:"280";s:3:" do";s:3:"281";s:3:" eu";s:3:"282";s:3:" fa";s:3:"283";s:3:" lo";s:3:"284";s:3:" ne";s:3:"285";s:3:" ra";s:3:"286";s:3:"arl";s:3:"287";s:3:"att";s:3:"288";s:3:"ec ";s:3:"289";s:3:"ica";s:3:"290";s:3:"l a";s:3:"291";s:3:"l'o";s:3:"292";s:4:"l'é";s:3:"293";s:3:"mmi";s:3:"294";s:3:"nta";s:3:"295";s:3:"orm";s:3:"296";s:3:"ou ";s:3:"297";s:3:"r u";s:3:"298";s:3:"rle";s:3:"299";}s:6:"german";a:300:{s:3:"en ";s:1:"0";s:3:"er ";s:1:"1";s:3:" de";s:1:"2";s:3:"der";s:1:"3";s:3:"ie ";s:1:"4";s:3:" di";s:1:"5";s:3:"die";s:1:"6";s:3:"sch";s:1:"7";s:3:"ein";s:1:"8";s:3:"che";s:1:"9";s:3:"ich";s:2:"10";s:3:"den";s:2:"11";s:3:"in ";s:2:"12";s:3:"te ";s:2:"13";s:3:"ch ";s:2:"14";s:3:" ei";s:2:"15";s:3:"ung";s:2:"16";s:3:"n d";s:2:"17";s:3:"nd ";s:2:"18";s:3:" be";s:2:"19";s:3:"ver";s:2:"20";s:3:"es ";s:2:"21";s:3:" zu";s:2:"22";s:3:"eit";s:2:"23";s:3:"gen";s:2:"24";s:3:"und";s:2:"25";s:3:" un";s:2:"26";s:3:" au";s:2:"27";s:3:" in";s:2:"28";s:3:"cht";s:2:"29";s:3:"it ";s:2:"30";s:3:"ten";s:2:"31";s:3:" da";s:2:"32";s:3:"ent";s:2:"33";s:3:" ve";s:2:"34";s:3:"and";s:2:"35";s:3:" ge";s:2:"36";s:3:"ine";s:2:"37";s:3:" mi";s:2:"38";s:3:"r d";s:2:"39";s:3:"hen";s:2:"40";s:3:"ng ";s:2:"41";s:3:"nde";s:2:"42";s:3:" vo";s:2:"43";s:3:"e d";s:2:"44";s:3:"ber";s:2:"45";s:3:"men";s:2:"46";s:3:"ei ";s:2:"47";s:3:"mit";s:2:"48";s:3:" st";s:2:"49";s:3:"ter";s:2:"50";s:3:"ren";s:2:"51";s:3:"t d";s:2:"52";s:3:" er";s:2:"53";s:3:"ere";s:2:"54";s:3:"n s";s:2:"55";s:3:"ste";s:2:"56";s:3:" se";s:2:"57";s:3:"e s";s:2:"58";s:3:"ht ";s:2:"59";s:3:"des";s:2:"60";s:3:"ist";s:2:"61";s:3:"ne ";s:2:"62";s:3:"auf";s:2:"63";s:3:"e a";s:2:"64";s:3:"isc";s:2:"65";s:3:"on ";s:2:"66";s:3:"rte";s:2:"67";s:3:" re";s:2:"68";s:3:" we";s:2:"69";s:3:"ges";s:2:"70";s:3:"uch";s:2:"71";s:4:" fü";s:2:"72";s:3:" so";s:2:"73";s:3:"bei";s:2:"74";s:3:"e e";s:2:"75";s:3:"nen";s:2:"76";s:3:"r s";s:2:"77";s:3:"ach";s:2:"78";s:4:"für";s:2:"79";s:3:"ier";s:2:"80";s:3:"par";s:2:"81";s:4:"ür ";s:2:"82";s:3:" ha";s:2:"83";s:3:"as ";s:2:"84";s:3:"ert";s:2:"85";s:3:" an";s:2:"86";s:3:" pa";s:2:"87";s:3:" sa";s:2:"88";s:3:" sp";s:2:"89";s:3:" wi";s:2:"90";s:3:"for";s:2:"91";s:3:"tag";s:2:"92";s:3:"zu ";s:2:"93";s:3:"das";s:2:"94";s:3:"rei";s:2:"95";s:3:"he ";s:2:"96";s:3:"hre";s:2:"97";s:3:"nte";s:2:"98";s:3:"sen";s:2:"99";s:3:"vor";s:3:"100";s:3:" sc";s:3:"101";s:3:"ech";s:3:"102";s:3:"etz";s:3:"103";s:3:"hei";s:3:"104";s:3:"lan";s:3:"105";s:3:"n a";s:3:"106";s:3:"pd ";s:3:"107";s:3:"st ";s:3:"108";s:3:"sta";s:3:"109";s:3:"ese";s:3:"110";s:3:"lic";s:3:"111";s:3:" ab";s:3:"112";s:3:" si";s:3:"113";s:3:"gte";s:3:"114";s:3:" wa";s:3:"115";s:3:"iti";s:3:"116";s:3:"kei";s:3:"117";s:3:"n e";s:3:"118";s:3:"nge";s:3:"119";s:3:"sei";s:3:"120";s:3:"tra";s:3:"121";s:3:"zen";s:3:"122";s:3:" im";s:3:"123";s:3:" la";s:3:"124";s:3:"art";s:3:"125";s:3:"im ";s:3:"126";s:3:"lle";s:3:"127";s:3:"n w";s:3:"128";s:3:"rde";s:3:"129";s:3:"rec";s:3:"130";s:3:"set";s:3:"131";s:3:"str";s:3:"132";s:3:"tei";s:3:"133";s:3:"tte";s:3:"134";s:3:" ni";s:3:"135";s:3:"e p";s:3:"136";s:3:"ehe";s:3:"137";s:3:"ers";s:3:"138";s:3:"g d";s:3:"139";s:3:"nic";s:3:"140";s:3:"von";s:3:"141";s:3:" al";s:3:"142";s:3:" pr";s:3:"143";s:3:"an ";s:3:"144";s:3:"aus";s:3:"145";s:3:"erf";s:3:"146";s:3:"r e";s:3:"147";s:3:"tze";s:3:"148";s:4:"tür";s:3:"149";s:3:"uf ";s:3:"150";s:3:"ag ";s:3:"151";s:3:"als";s:3:"152";s:3:"ar ";s:3:"153";s:3:"chs";s:3:"154";s:3:"end";s:3:"155";s:3:"ge ";s:3:"156";s:3:"ige";s:3:"157";s:3:"ion";s:3:"158";s:3:"ls ";s:3:"159";s:3:"n m";s:3:"160";s:3:"ngs";s:3:"161";s:3:"nis";s:3:"162";s:3:"nt ";s:3:"163";s:3:"ord";s:3:"164";s:3:"s s";s:3:"165";s:3:"sse";s:3:"166";s:4:" tü";s:3:"167";s:3:"ahl";s:3:"168";s:3:"e b";s:3:"169";s:3:"ede";s:3:"170";s:3:"em ";s:3:"171";s:3:"len";s:3:"172";s:3:"n i";s:3:"173";s:3:"orm";s:3:"174";s:3:"pro";s:3:"175";s:3:"rke";s:3:"176";s:3:"run";s:3:"177";s:3:"s d";s:3:"178";s:3:"wah";s:3:"179";s:3:"wer";s:3:"180";s:4:"ürk";s:3:"181";s:3:" me";s:3:"182";s:3:"age";s:3:"183";s:3:"att";s:3:"184";s:3:"ell";s:3:"185";s:3:"est";s:3:"186";s:3:"hat";s:3:"187";s:3:"n b";s:3:"188";s:3:"oll";s:3:"189";s:3:"raf";s:3:"190";s:3:"s a";s:3:"191";s:3:"tsc";s:3:"192";s:3:" es";s:3:"193";s:3:" fo";s:3:"194";s:3:" gr";s:3:"195";s:3:" ja";s:3:"196";s:3:"abe";s:3:"197";s:3:"auc";s:3:"198";s:3:"ben";s:3:"199";s:3:"e n";s:3:"200";s:3:"ege";s:3:"201";s:3:"lie";s:3:"202";s:3:"n u";s:3:"203";s:3:"r v";s:3:"204";s:3:"re ";s:3:"205";s:3:"rit";s:3:"206";s:3:"sag";s:3:"207";s:3:" am";s:3:"208";s:3:"agt";s:3:"209";s:3:"ahr";s:3:"210";s:3:"bra";s:3:"211";s:3:"de ";s:3:"212";s:3:"erd";s:3:"213";s:3:"her";s:3:"214";s:3:"ite";s:3:"215";s:3:"le ";s:3:"216";s:3:"n p";s:3:"217";s:3:"n v";s:3:"218";s:3:"or ";s:3:"219";s:3:"rbe";s:3:"220";s:3:"rt ";s:3:"221";s:3:"sic";s:3:"222";s:3:"wie";s:3:"223";s:4:"übe";s:3:"224";s:3:" is";s:3:"225";s:4:" üb";s:3:"226";s:3:"cha";s:3:"227";s:3:"chi";s:3:"228";s:3:"e f";s:3:"229";s:3:"e m";s:3:"230";s:3:"eri";s:3:"231";s:3:"ied";s:3:"232";s:3:"mme";s:3:"233";s:3:"ner";s:3:"234";s:3:"r a";s:3:"235";s:3:"sti";s:3:"236";s:3:"t a";s:3:"237";s:3:"t s";s:3:"238";s:3:"tis";s:3:"239";s:3:" ko";s:3:"240";s:3:"arb";s:3:"241";s:3:"ds ";s:3:"242";s:3:"gan";s:3:"243";s:3:"n z";s:3:"244";s:3:"r f";s:3:"245";s:3:"r w";s:3:"246";s:3:"ran";s:3:"247";s:3:"se ";s:3:"248";s:3:"t i";s:3:"249";s:3:"wei";s:3:"250";s:3:"wir";s:3:"251";s:3:" br";s:3:"252";s:3:" np";s:3:"253";s:3:"am ";s:3:"254";s:3:"bes";s:3:"255";s:3:"d d";s:3:"256";s:3:"deu";s:3:"257";s:3:"e g";s:3:"258";s:3:"e k";s:3:"259";s:3:"efo";s:3:"260";s:3:"et ";s:3:"261";s:3:"eut";s:3:"262";s:3:"fen";s:3:"263";s:3:"hse";s:3:"264";s:3:"lte";s:3:"265";s:3:"n r";s:3:"266";s:3:"npd";s:3:"267";s:3:"r b";s:3:"268";s:3:"rhe";s:3:"269";s:3:"t w";s:3:"270";s:3:"tz ";s:3:"271";s:3:" fr";s:3:"272";s:3:" ih";s:3:"273";s:3:" ke";s:3:"274";s:3:" ma";s:3:"275";s:3:"ame";s:3:"276";s:3:"ang";s:3:"277";s:3:"d s";s:3:"278";s:3:"eil";s:3:"279";s:3:"el ";s:3:"280";s:3:"era";s:3:"281";s:3:"erh";s:3:"282";s:3:"h d";s:3:"283";s:3:"i d";s:3:"284";s:3:"kan";s:3:"285";s:3:"n f";s:3:"286";s:3:"n l";s:3:"287";s:3:"nts";s:3:"288";s:3:"och";s:3:"289";s:3:"rag";s:3:"290";s:3:"rd ";s:3:"291";s:3:"spd";s:3:"292";s:3:"spr";s:3:"293";s:3:"tio";s:3:"294";s:3:" ar";s:3:"295";s:3:" en";s:3:"296";s:3:" ka";s:3:"297";s:3:"ark";s:3:"298";s:3:"ass";s:3:"299";}s:5:"hausa";a:300:{s:3:" da";s:1:"0";s:3:"da ";s:1:"1";s:3:"in ";s:1:"2";s:3:"an ";s:1:"3";s:3:"ya ";s:1:"4";s:3:" wa";s:1:"5";s:3:" ya";s:1:"6";s:3:"na ";s:1:"7";s:3:"ar ";s:1:"8";s:3:"a d";s:1:"9";s:3:" ma";s:2:"10";s:3:"wa ";s:2:"11";s:3:"a a";s:2:"12";s:3:"a k";s:2:"13";s:3:"a s";s:2:"14";s:3:" ta";s:2:"15";s:3:"wan";s:2:"16";s:3:" a ";s:2:"17";s:3:" ba";s:2:"18";s:3:" ka";s:2:"19";s:3:"ta ";s:2:"20";s:3:"a y";s:2:"21";s:3:"n d";s:2:"22";s:3:" ha";s:2:"23";s:3:" na";s:2:"24";s:3:" su";s:2:"25";s:3:" sa";s:2:"26";s:3:"kin";s:2:"27";s:3:"sa ";s:2:"28";s:3:"ata";s:2:"29";s:3:" ko";s:2:"30";s:3:"a t";s:2:"31";s:3:"su ";s:2:"32";s:3:" ga";s:2:"33";s:3:"ai ";s:2:"34";s:3:" sh";s:2:"35";s:3:"a m";s:2:"36";s:3:"uwa";s:2:"37";s:3:"iya";s:2:"38";s:3:"ma ";s:2:"39";s:3:"a w";s:2:"40";s:3:"asa";s:2:"41";s:3:"yan";s:2:"42";s:3:"ka ";s:2:"43";s:3:"ani";s:2:"44";s:3:"shi";s:2:"45";s:3:"a b";s:2:"46";s:3:"a h";s:2:"47";s:3:"a c";s:2:"48";s:3:"ama";s:2:"49";s:3:"ba ";s:2:"50";s:3:"nan";s:2:"51";s:3:"n a";s:2:"52";s:3:" mu";s:2:"53";s:3:"ana";s:2:"54";s:3:" yi";s:2:"55";s:3:"a g";s:2:"56";s:3:" za";s:2:"57";s:3:"i d";s:2:"58";s:3:" ku";s:2:"59";s:3:"aka";s:2:"60";s:3:"yi ";s:2:"61";s:3:"n k";s:2:"62";s:3:"ann";s:2:"63";s:3:"ke ";s:2:"64";s:3:"tar";s:2:"65";s:3:" ci";s:2:"66";s:3:"iki";s:2:"67";s:3:"n s";s:2:"68";s:3:"ko ";s:2:"69";s:3:" ra";s:2:"70";s:3:"ki ";s:2:"71";s:3:"ne ";s:2:"72";s:3:"a z";s:2:"73";s:3:"mat";s:2:"74";s:3:"hak";s:2:"75";s:3:"nin";s:2:"76";s:3:"e d";s:2:"77";s:3:"nna";s:2:"78";s:3:"uma";s:2:"79";s:3:"nda";s:2:"80";s:3:"a n";s:2:"81";s:3:"ada";s:2:"82";s:3:"cik";s:2:"83";s:3:"ni ";s:2:"84";s:3:"rin";s:2:"85";s:3:"una";s:2:"86";s:3:"ara";s:2:"87";s:3:"kum";s:2:"88";s:3:"akk";s:2:"89";s:3:" ce";s:2:"90";s:3:" du";s:2:"91";s:3:"man";s:2:"92";s:3:"n y";s:2:"93";s:3:"nci";s:2:"94";s:3:"sar";s:2:"95";s:3:"aki";s:2:"96";s:3:"awa";s:2:"97";s:3:"ci ";s:2:"98";s:3:"kan";s:2:"99";s:3:"kar";s:3:"100";s:3:"ari";s:3:"101";s:3:"n m";s:3:"102";s:3:"and";s:3:"103";s:3:"hi ";s:3:"104";s:3:"n t";s:3:"105";s:3:"ga ";s:3:"106";s:3:"owa";s:3:"107";s:3:"ash";s:3:"108";s:3:"kam";s:3:"109";s:3:"dan";s:3:"110";s:3:"ewa";s:3:"111";s:3:"nsa";s:3:"112";s:3:"ali";s:3:"113";s:3:"ami";s:3:"114";s:3:" ab";s:3:"115";s:3:" do";s:3:"116";s:3:"anc";s:3:"117";s:3:"n r";s:3:"118";s:3:"aya";s:3:"119";s:3:"i n";s:3:"120";s:3:"sun";s:3:"121";s:3:"uka";s:3:"122";s:3:" al";s:3:"123";s:3:" ne";s:3:"124";s:3:"a'a";s:3:"125";s:3:"cew";s:3:"126";s:3:"cin";s:3:"127";s:3:"mas";s:3:"128";s:3:"tak";s:3:"129";s:3:"un ";s:3:"130";s:3:"aba";s:3:"131";s:3:"kow";s:3:"132";s:3:"a r";s:3:"133";s:3:"ra ";s:3:"134";s:3:" ja";s:3:"135";s:4:" ƙa";s:3:"136";s:3:"en ";s:3:"137";s:3:"r d";s:3:"138";s:3:"sam";s:3:"139";s:3:"tsa";s:3:"140";s:3:" ru";s:3:"141";s:3:"ce ";s:3:"142";s:3:"i a";s:3:"143";s:3:"abi";s:3:"144";s:3:"ida";s:3:"145";s:3:"mut";s:3:"146";s:3:"n g";s:3:"147";s:3:"n j";s:3:"148";s:3:"san";s:3:"149";s:4:"a ƙ";s:3:"150";s:3:"har";s:3:"151";s:3:"on ";s:3:"152";s:3:"i m";s:3:"153";s:3:"suk";s:3:"154";s:3:" ak";s:3:"155";s:3:" ji";s:3:"156";s:3:"yar";s:3:"157";s:3:"'ya";s:3:"158";s:3:"kwa";s:3:"159";s:3:"min";s:3:"160";s:3:" 'y";s:3:"161";s:3:"ane";s:3:"162";s:3:"ban";s:3:"163";s:3:"ins";s:3:"164";s:3:"ruw";s:3:"165";s:3:"i k";s:3:"166";s:3:"n h";s:3:"167";s:3:" ad";s:3:"168";s:3:"ake";s:3:"169";s:3:"n w";s:3:"170";s:3:"sha";s:3:"171";s:3:"utu";s:3:"172";s:4:" ƴa";s:3:"173";s:3:"bay";s:3:"174";s:3:"tan";s:3:"175";s:4:"ƴan";s:3:"176";s:3:"bin";s:3:"177";s:3:"duk";s:3:"178";s:3:"e m";s:3:"179";s:3:"n n";s:3:"180";s:3:"oka";s:3:"181";s:3:"yin";s:3:"182";s:4:"ɗan";s:3:"183";s:3:" fa";s:3:"184";s:3:"a i";s:3:"185";s:3:"kki";s:3:"186";s:3:"re ";s:3:"187";s:3:"za ";s:3:"188";s:3:"ala";s:3:"189";s:3:"asu";s:3:"190";s:3:"han";s:3:"191";s:3:"i y";s:3:"192";s:3:"mar";s:3:"193";s:3:"ran";s:3:"194";s:4:"ƙas";s:3:"195";s:3:"add";s:3:"196";s:3:"ars";s:3:"197";s:3:"gab";s:3:"198";s:3:"ira";s:3:"199";s:3:"mma";s:3:"200";s:3:"u d";s:3:"201";s:3:" ts";s:3:"202";s:3:"abb";s:3:"203";s:3:"abu";s:3:"204";s:3:"aga";s:3:"205";s:3:"gar";s:3:"206";s:3:"n b";s:3:"207";s:4:" ɗa";s:3:"208";s:3:"aci";s:3:"209";s:3:"aik";s:3:"210";s:3:"am ";s:3:"211";s:3:"dun";s:3:"212";s:3:"e s";s:3:"213";s:3:"i b";s:3:"214";s:3:"i w";s:3:"215";s:3:"kas";s:3:"216";s:3:"kok";s:3:"217";s:3:"wam";s:3:"218";s:3:" am";s:3:"219";s:3:"amf";s:3:"220";s:3:"bba";s:3:"221";s:3:"din";s:3:"222";s:3:"fan";s:3:"223";s:3:"gwa";s:3:"224";s:3:"i s";s:3:"225";s:3:"wat";s:3:"226";s:3:"ano";s:3:"227";s:3:"are";s:3:"228";s:3:"dai";s:3:"229";s:3:"iri";s:3:"230";s:3:"ma'";s:3:"231";s:3:" la";s:3:"232";s:3:"all";s:3:"233";s:3:"dam";s:3:"234";s:3:"ika";s:3:"235";s:3:"mi ";s:3:"236";s:3:"she";s:3:"237";s:3:"tum";s:3:"238";s:3:"uni";s:3:"239";s:3:" an";s:3:"240";s:3:" ai";s:3:"241";s:3:" ke";s:3:"242";s:3:" ki";s:3:"243";s:3:"dag";s:3:"244";s:3:"mai";s:3:"245";s:3:"mfa";s:3:"246";s:3:"no ";s:3:"247";s:3:"nsu";s:3:"248";s:3:"o d";s:3:"249";s:3:"sak";s:3:"250";s:3:"um ";s:3:"251";s:3:" bi";s:3:"252";s:3:" gw";s:3:"253";s:3:" kw";s:3:"254";s:3:"jam";s:3:"255";s:3:"yya";s:3:"256";s:3:"a j";s:3:"257";s:3:"fa ";s:3:"258";s:3:"uta";s:3:"259";s:3:" hu";s:3:"260";s:3:"'a ";s:3:"261";s:3:"ans";s:3:"262";s:4:"aɗa";s:3:"263";s:3:"dda";s:3:"264";s:3:"hin";s:3:"265";s:3:"niy";s:3:"266";s:3:"r s";s:3:"267";s:3:"bat";s:3:"268";s:3:"dar";s:3:"269";s:3:"gan";s:3:"270";s:3:"i t";s:3:"271";s:3:"nta";s:3:"272";s:3:"oki";s:3:"273";s:3:"omi";s:3:"274";s:3:"sal";s:3:"275";s:3:"a l";s:3:"276";s:3:"kac";s:3:"277";s:3:"lla";s:3:"278";s:3:"wad";s:3:"279";s:3:"war";s:3:"280";s:3:"amm";s:3:"281";s:3:"dom";s:3:"282";s:3:"r m";s:3:"283";s:3:"ras";s:3:"284";s:3:"sai";s:3:"285";s:3:" lo";s:3:"286";s:3:"ats";s:3:"287";s:3:"hal";s:3:"288";s:3:"kat";s:3:"289";s:3:"li ";s:3:"290";s:3:"lok";s:3:"291";s:3:"n c";s:3:"292";s:3:"nar";s:3:"293";s:3:"tin";s:3:"294";s:3:"afa";s:3:"295";s:3:"bub";s:3:"296";s:3:"i g";s:3:"297";s:3:"isa";s:3:"298";s:3:"mak";s:3:"299";}s:8:"hawaiian";a:300:{s:3:" ka";s:1:"0";s:3:"na ";s:1:"1";s:3:" o ";s:1:"2";s:3:"ka ";s:1:"3";s:3:" ma";s:1:"4";s:3:" a ";s:1:"5";s:3:" la";s:1:"6";s:3:"a i";s:1:"7";s:3:"a m";s:1:"8";s:3:" i ";s:1:"9";s:3:"la ";s:2:"10";s:3:"ana";s:2:"11";s:3:"ai ";s:2:"12";s:3:"ia ";s:2:"13";s:3:"a o";s:2:"14";s:3:"a k";s:2:"15";s:3:"a h";s:2:"16";s:3:"o k";s:2:"17";s:3:" ke";s:2:"18";s:3:"a a";s:2:"19";s:3:"i k";s:2:"20";s:3:" ho";s:2:"21";s:3:" ia";s:2:"22";s:3:"ua ";s:2:"23";s:3:" na";s:2:"24";s:3:" me";s:2:"25";s:3:"e k";s:2:"26";s:3:"e a";s:2:"27";s:3:"au ";s:2:"28";s:3:"ke ";s:2:"29";s:3:"ma ";s:2:"30";s:3:"mai";s:2:"31";s:3:"aku";s:2:"32";s:3:" ak";s:2:"33";s:3:"ahi";s:2:"34";s:3:" ha";s:2:"35";s:3:" ko";s:2:"36";s:3:" e ";s:2:"37";s:3:"a l";s:2:"38";s:3:" no";s:2:"39";s:3:"me ";s:2:"40";s:3:"ku ";s:2:"41";s:3:"aka";s:2:"42";s:3:"kan";s:2:"43";s:3:"no ";s:2:"44";s:3:"i a";s:2:"45";s:3:"ho ";s:2:"46";s:3:"ou ";s:2:"47";s:3:" ai";s:2:"48";s:3:"i o";s:2:"49";s:3:"a p";s:2:"50";s:3:"o l";s:2:"51";s:3:"o a";s:2:"52";s:3:"ama";s:2:"53";s:3:"a n";s:2:"54";s:3:" an";s:2:"55";s:3:"i m";s:2:"56";s:3:"han";s:2:"57";s:3:"i i";s:2:"58";s:3:"iho";s:2:"59";s:3:"kou";s:2:"60";s:3:"ne ";s:2:"61";s:3:" ih";s:2:"62";s:3:"o i";s:2:"63";s:3:"iki";s:2:"64";s:3:"ona";s:2:"65";s:3:"hoo";s:2:"66";s:3:"le ";s:2:"67";s:3:"e h";s:2:"68";s:3:" he";s:2:"69";s:3:"ina";s:2:"70";s:3:" wa";s:2:"71";s:3:"ea ";s:2:"72";s:3:"ako";s:2:"73";s:3:"u i";s:2:"74";s:3:"kah";s:2:"75";s:3:"oe ";s:2:"76";s:3:"i l";s:2:"77";s:3:"u a";s:2:"78";s:3:" pa";s:2:"79";s:3:"hoi";s:2:"80";s:3:"e i";s:2:"81";s:3:"era";s:2:"82";s:3:"ko ";s:2:"83";s:3:"u m";s:2:"84";s:3:"kua";s:2:"85";s:3:"mak";s:2:"86";s:3:"oi ";s:2:"87";s:3:"kai";s:2:"88";s:3:"i n";s:2:"89";s:3:"a e";s:2:"90";s:3:"hin";s:2:"91";s:3:"ane";s:2:"92";s:3:" ol";s:2:"93";s:3:"i h";s:2:"94";s:3:"mea";s:2:"95";s:3:"wah";s:2:"96";s:3:"lak";s:2:"97";s:3:"e m";s:2:"98";s:3:"o n";s:2:"99";s:3:"u l";s:3:"100";s:3:"ika";s:3:"101";s:3:"ki ";s:3:"102";s:3:"a w";s:3:"103";s:3:"mal";s:3:"104";s:3:"hi ";s:3:"105";s:3:"e n";s:3:"106";s:3:"u o";s:3:"107";s:3:"hik";s:3:"108";s:3:" ku";s:3:"109";s:3:"e l";s:3:"110";s:3:"ele";s:3:"111";s:3:"ra ";s:3:"112";s:3:"ber";s:3:"113";s:3:"ine";s:3:"114";s:3:"abe";s:3:"115";s:3:"ain";s:3:"116";s:3:"ala";s:3:"117";s:3:"lo ";s:3:"118";s:3:" po";s:3:"119";s:3:"kon";s:3:"120";s:3:" ab";s:3:"121";s:3:"ole";s:3:"122";s:3:"he ";s:3:"123";s:3:"pau";s:3:"124";s:3:"mah";s:3:"125";s:3:"va ";s:3:"126";s:3:"ela";s:3:"127";s:3:"kau";s:3:"128";s:3:"nak";s:3:"129";s:3:" oe";s:3:"130";s:3:"kei";s:3:"131";s:3:"oia";s:3:"132";s:3:" ie";s:3:"133";s:3:"ram";s:3:"134";s:3:" oi";s:3:"135";s:3:"oa ";s:3:"136";s:3:"eho";s:3:"137";s:3:"hov";s:3:"138";s:3:"ieh";s:3:"139";s:3:"ova";s:3:"140";s:3:" ua";s:3:"141";s:3:"una";s:3:"142";s:3:"ara";s:3:"143";s:3:"o s";s:3:"144";s:3:"awa";s:3:"145";s:3:"o o";s:3:"146";s:3:"nau";s:3:"147";s:3:"u n";s:3:"148";s:3:"wa ";s:3:"149";s:3:"wai";s:3:"150";s:3:"hel";s:3:"151";s:3:" ae";s:3:"152";s:3:" al";s:3:"153";s:3:"ae ";s:3:"154";s:3:"ta ";s:3:"155";s:3:"aik";s:3:"156";s:3:" hi";s:3:"157";s:3:"ale";s:3:"158";s:3:"ila";s:3:"159";s:3:"lel";s:3:"160";s:3:"ali";s:3:"161";s:3:"eik";s:3:"162";s:3:"olo";s:3:"163";s:3:"onu";s:3:"164";s:3:" lo";s:3:"165";s:3:"aua";s:3:"166";s:3:"e o";s:3:"167";s:3:"ola";s:3:"168";s:3:"hon";s:3:"169";s:3:"mam";s:3:"170";s:3:"nan";s:3:"171";s:3:" au";s:3:"172";s:3:"aha";s:3:"173";s:3:"lau";s:3:"174";s:3:"nua";s:3:"175";s:3:"oho";s:3:"176";s:3:"oma";s:3:"177";s:3:" ao";s:3:"178";s:3:"ii ";s:3:"179";s:3:"alu";s:3:"180";s:3:"ima";s:3:"181";s:3:"mau";s:3:"182";s:3:"ike";s:3:"183";s:3:"apa";s:3:"184";s:3:"elo";s:3:"185";s:3:"lii";s:3:"186";s:3:"poe";s:3:"187";s:3:"aia";s:3:"188";s:3:"noa";s:3:"189";s:3:" in";s:3:"190";s:3:"o m";s:3:"191";s:3:"oka";s:3:"192";s:3:"'u ";s:3:"193";s:3:"aho";s:3:"194";s:3:"ei ";s:3:"195";s:3:"eka";s:3:"196";s:3:"ha ";s:3:"197";s:3:"lu ";s:3:"198";s:3:"nei";s:3:"199";s:3:"hol";s:3:"200";s:3:"ino";s:3:"201";s:3:"o e";s:3:"202";s:3:"ema";s:3:"203";s:3:"iwa";s:3:"204";s:3:"olu";s:3:"205";s:3:"ada";s:3:"206";s:3:"naa";s:3:"207";s:3:"pa ";s:3:"208";s:3:"u k";s:3:"209";s:3:"ewa";s:3:"210";s:3:"hua";s:3:"211";s:3:"lam";s:3:"212";s:3:"lua";s:3:"213";s:3:"o h";s:3:"214";s:3:"ook";s:3:"215";s:3:"u h";s:3:"216";s:3:" li";s:3:"217";s:3:"ahu";s:3:"218";s:3:"amu";s:3:"219";s:3:"ui ";s:3:"220";s:3:" il";s:3:"221";s:3:" mo";s:3:"222";s:3:" se";s:3:"223";s:3:"eia";s:3:"224";s:3:"law";s:3:"225";s:3:" hu";s:3:"226";s:3:" ik";s:3:"227";s:3:"ail";s:3:"228";s:3:"e p";s:3:"229";s:3:"li ";s:3:"230";s:3:"lun";s:3:"231";s:3:"uli";s:3:"232";s:3:"io ";s:3:"233";s:3:"kik";s:3:"234";s:3:"noh";s:3:"235";s:3:"u e";s:3:"236";s:3:" sa";s:3:"237";s:3:"aaw";s:3:"238";s:3:"awe";s:3:"239";s:3:"ena";s:3:"240";s:3:"hal";s:3:"241";s:3:"kol";s:3:"242";s:3:"lan";s:3:"243";s:3:" le";s:3:"244";s:3:" ne";s:3:"245";s:3:"a'u";s:3:"246";s:3:"ilo";s:3:"247";s:3:"kap";s:3:"248";s:3:"oko";s:3:"249";s:3:"sa ";s:3:"250";s:3:" pe";s:3:"251";s:3:"hop";s:3:"252";s:3:"loa";s:3:"253";s:3:"ope";s:3:"254";s:3:"pe ";s:3:"255";s:3:" ad";s:3:"256";s:3:" pu";s:3:"257";s:3:"ahe";s:3:"258";s:3:"aol";s:3:"259";s:3:"ia'";s:3:"260";s:3:"lai";s:3:"261";s:3:"loh";s:3:"262";s:3:"na'";s:3:"263";s:3:"oom";s:3:"264";s:3:"aau";s:3:"265";s:3:"eri";s:3:"266";s:3:"kul";s:3:"267";s:3:"we ";s:3:"268";s:3:"ake";s:3:"269";s:3:"kek";s:3:"270";s:3:"laa";s:3:"271";s:3:"ri ";s:3:"272";s:3:"iku";s:3:"273";s:3:"kak";s:3:"274";s:3:"lim";s:3:"275";s:3:"nah";s:3:"276";s:3:"ner";s:3:"277";s:3:"nui";s:3:"278";s:3:"ono";s:3:"279";s:3:"a u";s:3:"280";s:3:"dam";s:3:"281";s:3:"kum";s:3:"282";s:3:"lok";s:3:"283";s:3:"mua";s:3:"284";s:3:"uma";s:3:"285";s:3:"wal";s:3:"286";s:3:"wi ";s:3:"287";s:3:"'i ";s:3:"288";s:3:"a'i";s:3:"289";s:3:"aan";s:3:"290";s:3:"alo";s:3:"291";s:3:"eta";s:3:"292";s:3:"mu ";s:3:"293";s:3:"ohe";s:3:"294";s:3:"u p";s:3:"295";s:3:"ula";s:3:"296";s:3:"uwa";s:3:"297";s:3:" nu";s:3:"298";s:3:"amo";s:3:"299";}s:5:"hindi";a:300:{s:7:"ें ";s:1:"0";s:7:" है";s:1:"1";s:9:"में";s:1:"2";s:7:" मे";s:1:"3";s:7:"ने ";s:1:"4";s:7:"की ";s:1:"5";s:7:"के ";s:1:"6";s:7:"है ";s:1:"7";s:7:" के";s:1:"8";s:7:" की";s:1:"9";s:7:" को";s:2:"10";s:7:"ों ";s:2:"11";s:7:"को ";s:2:"12";s:7:"ा ह";s:2:"13";s:7:" का";s:2:"14";s:7:"से ";s:2:"15";s:7:"ा क";s:2:"16";s:7:"े क";s:2:"17";s:7:"ं क";s:2:"18";s:7:"या ";s:2:"19";s:7:" कि";s:2:"20";s:7:" से";s:2:"21";s:7:"का ";s:2:"22";s:7:"ी क";s:2:"23";s:7:" ने";s:2:"24";s:7:" और";s:2:"25";s:7:"और ";s:2:"26";s:7:"ना ";s:2:"27";s:7:"कि ";s:2:"28";s:7:"भी ";s:2:"29";s:7:"ी स";s:2:"30";s:7:" जा";s:2:"31";s:7:" पर";s:2:"32";s:7:"ार ";s:2:"33";s:7:" कर";s:2:"34";s:7:"ी ह";s:2:"35";s:7:" हो";s:2:"36";s:7:"ही ";s:2:"37";s:9:"िया";s:2:"38";s:7:" इस";s:2:"39";s:7:" रह";s:2:"40";s:7:"र क";s:2:"41";s:9:"ुना";s:2:"42";s:7:"ता ";s:2:"43";s:7:"ान ";s:2:"44";s:7:"े स";s:2:"45";s:7:" भी";s:2:"46";s:7:" रा";s:2:"47";s:7:"े ह";s:2:"48";s:7:" चु";s:2:"49";s:7:" पा";s:2:"50";s:7:"पर ";s:2:"51";s:9:"चुन";s:2:"52";s:9:"नाव";s:2:"53";s:7:" कह";s:2:"54";s:9:"प्र";s:2:"55";s:7:" भा";s:2:"56";s:9:"राज";s:2:"57";s:9:"हैं";s:2:"58";s:7:"ा स";s:2:"59";s:7:"ै क";s:2:"60";s:7:"ैं ";s:2:"61";s:7:"नी ";s:2:"62";s:7:"ल क";s:2:"63";s:7:"ीं ";s:2:"64";s:7:"़ी ";s:2:"65";s:7:"था ";s:2:"66";s:7:"री ";s:2:"67";s:7:"ाव ";s:2:"68";s:7:"े ब";s:2:"69";s:7:" प्";s:2:"70";s:9:"क्ष";s:2:"71";s:7:"पा ";s:2:"72";s:7:"ले ";s:2:"73";s:7:" दे";s:2:"74";s:7:"ला ";s:2:"75";s:7:"हा ";s:2:"76";s:9:"ाजप";s:2:"77";s:7:" था";s:2:"78";s:7:" नह";s:2:"79";s:7:"इस ";s:2:"80";s:7:"कर ";s:2:"81";s:9:"जपा";s:2:"82";s:9:"नही";s:2:"83";s:9:"भाज";s:2:"84";s:9:"यों";s:2:"85";s:7:"र स";s:2:"86";s:9:"हीं";s:2:"87";s:7:" अम";s:2:"88";s:7:" बा";s:2:"89";s:7:" मा";s:2:"90";s:7:" वि";s:2:"91";s:9:"रीक";s:2:"92";s:7:"िए ";s:2:"93";s:7:"े प";s:2:"94";s:9:"्या";s:2:"95";s:7:" ही";s:2:"96";s:7:"ं म";s:2:"97";s:9:"कार";s:2:"98";s:7:"ा ज";s:2:"99";s:7:"े ल";s:3:"100";s:7:" ता";s:3:"101";s:7:" दि";s:3:"102";s:7:" सा";s:3:"103";s:7:" हम";s:3:"104";s:7:"ा न";s:3:"105";s:7:"ा म";s:3:"106";s:9:"ाक़";s:3:"107";s:9:"्ता";s:3:"108";s:7:" एक";s:3:"109";s:7:" सं";s:3:"110";s:7:" स्";s:3:"111";s:9:"अमर";s:3:"112";s:9:"क़ी";s:3:"113";s:9:"ताज";s:3:"114";s:9:"मरी";s:3:"115";s:9:"स्थ";s:3:"116";s:7:"ा थ";s:3:"117";s:9:"ार्";s:3:"118";s:7:" हु";s:3:"119";s:9:"इरा";s:3:"120";s:7:"एक ";s:3:"121";s:7:"न क";s:3:"122";s:7:"र म";s:3:"123";s:9:"राक";s:3:"124";s:7:"ी ज";s:3:"125";s:7:"ी न";s:3:"126";s:7:" इर";s:3:"127";s:7:" उन";s:3:"128";s:7:" पह";s:3:"129";s:9:"कहा";s:3:"130";s:7:"ते ";s:3:"131";s:7:"े अ";s:3:"132";s:7:" तो";s:3:"133";s:7:" सु";s:3:"134";s:7:"ति ";s:3:"135";s:7:"ती ";s:3:"136";s:7:"तो ";s:3:"137";s:9:"मिल";s:3:"138";s:7:"िक ";s:3:"139";s:9:"ियो";s:3:"140";s:9:"्रे";s:3:"141";s:7:" अप";s:3:"142";s:7:" फ़";s:3:"143";s:7:" लि";s:3:"144";s:7:" लो";s:3:"145";s:7:" सम";s:3:"146";s:7:"म क";s:3:"147";s:9:"र्ट";s:3:"148";s:7:"हो ";s:3:"149";s:7:"ा च";s:3:"150";s:7:"ाई ";s:3:"151";s:9:"ाने";s:3:"152";s:7:"िन ";s:3:"153";s:7:"्य ";s:3:"154";s:7:" उस";s:3:"155";s:7:" क़";s:3:"156";s:7:" सक";s:3:"157";s:7:" सै";s:3:"158";s:7:"ं प";s:3:"159";s:7:"ं ह";s:3:"160";s:7:"गी ";s:3:"161";s:7:"त क";s:3:"162";s:9:"मान";s:3:"163";s:7:"र न";s:3:"164";s:9:"ष्ट";s:3:"165";s:7:"स क";s:3:"166";s:9:"स्त";s:3:"167";s:7:"ाँ ";s:3:"168";s:7:"ी ब";s:3:"169";s:7:"ी म";s:3:"170";s:9:"्री";s:3:"171";s:7:" दो";s:3:"172";s:7:" मि";s:3:"173";s:7:" मु";s:3:"174";s:7:" ले";s:3:"175";s:7:" शा";s:3:"176";s:7:"ं स";s:3:"177";s:9:"ज़ा";s:3:"178";s:9:"त्र";s:3:"179";s:7:"थी ";s:3:"180";s:9:"लिए";s:3:"181";s:7:"सी ";s:3:"182";s:7:"़ा ";s:3:"183";s:9:"़ार";s:3:"184";s:9:"ांग";s:3:"185";s:7:"े द";s:3:"186";s:7:"े म";s:3:"187";s:7:"्व ";s:3:"188";s:7:" ना";s:3:"189";s:7:" बन";s:3:"190";s:9:"ंग्";s:3:"191";s:9:"कां";s:3:"192";s:7:"गा ";s:3:"193";s:9:"ग्र";s:3:"194";s:7:"जा ";s:3:"195";s:9:"ज्य";s:3:"196";s:7:"दी ";s:3:"197";s:7:"न म";s:3:"198";s:9:"पार";s:3:"199";s:7:"भा ";s:3:"200";s:9:"रही";s:3:"201";s:7:"रे ";s:3:"202";s:9:"रेस";s:3:"203";s:7:"ली ";s:3:"204";s:9:"सभा";s:3:"205";s:7:"ा र";s:3:"206";s:7:"ाल ";s:3:"207";s:7:"ी अ";s:3:"208";s:9:"ीकी";s:3:"209";s:7:"े त";s:3:"210";s:7:"ेश ";s:3:"211";s:7:" अं";s:3:"212";s:7:" तक";s:3:"213";s:7:" या";s:3:"214";s:7:"ई ह";s:3:"215";s:9:"करन";s:3:"216";s:7:"तक ";s:3:"217";s:9:"देश";s:3:"218";s:9:"वर्";s:3:"219";s:9:"ाया";s:3:"220";s:7:"ी भ";s:3:"221";s:7:"ेस ";s:3:"222";s:7:"्ष ";s:3:"223";s:7:" गय";s:3:"224";s:7:" जि";s:3:"225";s:7:" थी";s:3:"226";s:7:" बड";s:3:"227";s:7:" यह";s:3:"228";s:7:" वा";s:3:"229";s:9:"ंतर";s:3:"230";s:9:"अंत";s:3:"231";s:7:"क़ ";s:3:"232";s:9:"गया";s:3:"233";s:7:"टी ";s:3:"234";s:9:"निक";s:3:"235";s:9:"न्ह";s:3:"236";s:9:"पहल";s:3:"237";s:9:"बड़";s:3:"238";s:9:"मार";s:3:"239";s:7:"र प";s:3:"240";s:9:"रने";s:3:"241";s:9:"ाज़";s:3:"242";s:7:"ि इ";s:3:"243";s:7:"ी र";s:3:"244";s:7:"े ज";s:3:"245";s:7:"े व";s:3:"246";s:7:"्ट ";s:3:"247";s:9:"्टी";s:3:"248";s:7:" अब";s:3:"249";s:7:" लग";s:3:"250";s:7:" वर";s:3:"251";s:7:" सी";s:3:"252";s:7:"ं भ";s:3:"253";s:9:"उन्";s:3:"254";s:7:"क क";s:3:"255";s:9:"किय";s:3:"256";s:9:"देख";s:3:"257";s:9:"पूर";s:3:"258";s:9:"फ़्";s:3:"259";s:7:"यह ";s:3:"260";s:9:"यान";s:3:"261";s:9:"रिक";s:3:"262";s:9:"रिय";s:3:"263";s:9:"र्ड";s:3:"264";s:9:"लेक";s:3:"265";s:9:"सकत";s:3:"266";s:9:"हों";s:3:"267";s:9:"होग";s:3:"268";s:7:"ा अ";s:3:"269";s:7:"ा द";s:3:"270";s:7:"ा प";s:3:"271";s:7:"ाद ";s:3:"272";s:9:"ारा";s:3:"273";s:7:"ित ";s:3:"274";s:7:"ी त";s:3:"275";s:7:"ी प";s:3:"276";s:7:"ो क";s:3:"277";s:7:"ो द";s:3:"278";s:7:" ते";s:3:"279";s:7:" नि";s:3:"280";s:7:" सर";s:3:"281";s:7:" हा";s:3:"282";s:7:"ं द";s:3:"283";s:9:"अपन";s:3:"284";s:9:"जान";s:3:"285";s:7:"त म";s:3:"286";s:9:"थित";s:3:"287";s:9:"पनी";s:3:"288";s:9:"महल";s:3:"289";s:7:"र ह";s:3:"290";s:9:"लोग";s:3:"291";s:7:"व क";s:3:"292";s:9:"हना";s:3:"293";s:7:"हल ";s:3:"294";s:9:"हाँ";s:3:"295";s:9:"ाज्";s:3:"296";s:9:"ाना";s:3:"297";s:9:"िक्";s:3:"298";s:9:"िस्";s:3:"299";}s:9:"hungarian";a:300:{s:3:" a ";s:1:"0";s:3:" az";s:1:"1";s:3:" sz";s:1:"2";s:3:"az ";s:1:"3";s:3:" me";s:1:"4";s:3:"en ";s:1:"5";s:3:" el";s:1:"6";s:3:" ho";s:1:"7";s:3:"ek ";s:1:"8";s:3:"gy ";s:1:"9";s:3:"tt ";s:2:"10";s:3:"ett";s:2:"11";s:3:"sze";s:2:"12";s:3:" fe";s:2:"13";s:4:"és ";s:2:"14";s:3:" ki";s:2:"15";s:3:"tet";s:2:"16";s:3:" be";s:2:"17";s:3:"et ";s:2:"18";s:3:"ter";s:2:"19";s:4:" kö";s:2:"20";s:4:" és";s:2:"21";s:3:"hog";s:2:"22";s:3:"meg";s:2:"23";s:3:"ogy";s:2:"24";s:3:"szt";s:2:"25";s:3:"te ";s:2:"26";s:3:"t a";s:2:"27";s:3:"zet";s:2:"28";s:3:"a m";s:2:"29";s:3:"nek";s:2:"30";s:3:"nt ";s:2:"31";s:4:"ség";s:2:"32";s:4:"szá";s:2:"33";s:3:"ak ";s:2:"34";s:3:" va";s:2:"35";s:3:"an ";s:2:"36";s:3:"eze";s:2:"37";s:3:"ra ";s:2:"38";s:3:"ta ";s:2:"39";s:3:" mi";s:2:"40";s:3:"int";s:2:"41";s:4:"köz";s:2:"42";s:3:" is";s:2:"43";s:3:"esz";s:2:"44";s:3:"fel";s:2:"45";s:3:"min";s:2:"46";s:3:"nak";s:2:"47";s:3:"ors";s:2:"48";s:3:"zer";s:2:"49";s:3:" te";s:2:"50";s:3:"a a";s:2:"51";s:3:"a k";s:2:"52";s:3:"is ";s:2:"53";s:3:" cs";s:2:"54";s:3:"ele";s:2:"55";s:3:"er ";s:2:"56";s:3:"men";s:2:"57";s:3:"si ";s:2:"58";s:3:"tek";s:2:"59";s:3:"ti ";s:2:"60";s:3:" ne";s:2:"61";s:3:"csa";s:2:"62";s:3:"ent";s:2:"63";s:3:"z e";s:2:"64";s:3:"a t";s:2:"65";s:3:"ala";s:2:"66";s:3:"ere";s:2:"67";s:3:"es ";s:2:"68";s:3:"lom";s:2:"69";s:3:"lte";s:2:"70";s:3:"mon";s:2:"71";s:3:"ond";s:2:"72";s:3:"rsz";s:2:"73";s:3:"sza";s:2:"74";s:3:"tte";s:2:"75";s:4:"zág";s:2:"76";s:4:"ány";s:2:"77";s:3:" fo";s:2:"78";s:3:" ma";s:2:"79";s:3:"ai ";s:2:"80";s:3:"ben";s:2:"81";s:3:"el ";s:2:"82";s:3:"ene";s:2:"83";s:3:"ik ";s:2:"84";s:3:"jel";s:2:"85";s:4:"tás";s:2:"86";s:4:"áll";s:2:"87";s:3:" ha";s:2:"88";s:3:" le";s:2:"89";s:4:" ál";s:2:"90";s:3:"agy";s:2:"91";s:4:"alá";s:2:"92";s:3:"isz";s:2:"93";s:3:"y a";s:2:"94";s:3:"zte";s:2:"95";s:4:"ás ";s:2:"96";s:3:" al";s:2:"97";s:3:"e a";s:2:"98";s:3:"egy";s:2:"99";s:3:"ely";s:3:"100";s:3:"for";s:3:"101";s:3:"lat";s:3:"102";s:3:"lt ";s:3:"103";s:3:"n a";s:3:"104";s:3:"oga";s:3:"105";s:3:"on ";s:3:"106";s:3:"re ";s:3:"107";s:3:"st ";s:3:"108";s:4:"ság";s:3:"109";s:3:"t m";s:3:"110";s:4:"án ";s:3:"111";s:4:"ét ";s:3:"112";s:4:"ült";s:3:"113";s:3:" je";s:3:"114";s:3:"gi ";s:3:"115";s:3:"k a";s:3:"116";s:4:"kül";s:3:"117";s:3:"lam";s:3:"118";s:3:"len";s:3:"119";s:4:"lás";s:3:"120";s:4:"más";s:3:"121";s:3:"s k";s:3:"122";s:3:"vez";s:3:"123";s:4:"áso";s:3:"124";s:5:"özö";s:3:"125";s:3:" ta";s:3:"126";s:3:"a s";s:3:"127";s:3:"a v";s:3:"128";s:3:"asz";s:3:"129";s:4:"atá";s:3:"130";s:4:"ető";s:3:"131";s:3:"kez";s:3:"132";s:3:"let";s:3:"133";s:3:"mag";s:3:"134";s:3:"nem";s:3:"135";s:4:"szé";s:3:"136";s:3:"z m";s:3:"137";s:4:"át ";s:3:"138";s:4:"éte";s:3:"139";s:4:"ölt";s:3:"140";s:3:" de";s:3:"141";s:3:" gy";s:3:"142";s:4:" ké";s:3:"143";s:3:" mo";s:3:"144";s:4:" vá";s:3:"145";s:4:" ér";s:3:"146";s:3:"a b";s:3:"147";s:3:"a f";s:3:"148";s:3:"ami";s:3:"149";s:3:"at ";s:3:"150";s:3:"ato";s:3:"151";s:3:"att";s:3:"152";s:3:"bef";s:3:"153";s:3:"dta";s:3:"154";s:3:"gya";s:3:"155";s:3:"hat";s:3:"156";s:3:"i s";s:3:"157";s:3:"las";s:3:"158";s:3:"ndt";s:3:"159";s:3:"rt ";s:3:"160";s:3:"szo";s:3:"161";s:3:"t k";s:3:"162";s:4:"tár";s:3:"163";s:4:"tés";s:3:"164";s:3:"van";s:3:"165";s:5:"ásá";s:3:"166";s:4:"ól ";s:3:"167";s:4:" bé";s:3:"168";s:3:" eg";s:3:"169";s:3:" or";s:3:"170";s:4:" pá";s:3:"171";s:4:" pé";s:3:"172";s:3:" ve";s:3:"173";s:3:"ban";s:3:"174";s:3:"eke";s:3:"175";s:4:"ekü";s:3:"176";s:4:"elő";s:3:"177";s:3:"erv";s:3:"178";s:3:"ete";s:3:"179";s:3:"fog";s:3:"180";s:3:"i a";s:3:"181";s:3:"kis";s:3:"182";s:4:"lád";s:3:"183";s:3:"nte";s:3:"184";s:3:"nye";s:3:"185";s:3:"nyi";s:3:"186";s:3:"ok ";s:3:"187";s:4:"omá";s:3:"188";s:3:"os ";s:3:"189";s:4:"rán";s:3:"190";s:4:"rás";s:3:"191";s:3:"sal";s:3:"192";s:3:"t e";s:3:"193";s:4:"vál";s:3:"194";s:3:"yar";s:3:"195";s:4:"ágo";s:3:"196";s:4:"ála";s:3:"197";s:4:"ége";s:3:"198";s:4:"ény";s:3:"199";s:4:"ött";s:3:"200";s:4:" tá";s:3:"201";s:4:"adó";s:3:"202";s:3:"elh";s:3:"203";s:3:"fej";s:3:"204";s:3:"het";s:3:"205";s:3:"hoz";s:3:"206";s:3:"ill";s:3:"207";s:4:"jár";s:3:"208";s:4:"kés";s:3:"209";s:3:"llo";s:3:"210";s:3:"mi ";s:3:"211";s:3:"ny ";s:3:"212";s:3:"ont";s:3:"213";s:3:"ren";s:3:"214";s:3:"res";s:3:"215";s:3:"rin";s:3:"216";s:3:"s a";s:3:"217";s:3:"s e";s:3:"218";s:3:"ssz";s:3:"219";s:3:"zt ";s:3:"220";s:3:" ez";s:3:"221";s:3:" ka";s:3:"222";s:3:" ke";s:3:"223";s:3:" ko";s:3:"224";s:3:" re";s:3:"225";s:3:"a h";s:3:"226";s:3:"a n";s:3:"227";s:3:"den";s:3:"228";s:4:"dó ";s:3:"229";s:3:"efo";s:3:"230";s:3:"gad";s:3:"231";s:3:"gat";s:3:"232";s:3:"gye";s:3:"233";s:3:"hel";s:3:"234";s:3:"k e";s:3:"235";s:3:"ket";s:3:"236";s:3:"les";s:3:"237";s:4:"mán";s:3:"238";s:3:"nde";s:3:"239";s:3:"nis";s:3:"240";s:3:"ozz";s:3:"241";s:3:"t b";s:3:"242";s:3:"t i";s:3:"243";s:4:"t é";s:3:"244";s:3:"tat";s:3:"245";s:3:"tos";s:3:"246";s:3:"val";s:3:"247";s:3:"z o";s:3:"248";s:3:"zak";s:3:"249";s:4:"ád ";s:3:"250";s:4:"ály";s:3:"251";s:4:"ára";s:3:"252";s:4:"ési";s:3:"253";s:4:"ész";s:3:"254";s:3:" ak";s:3:"255";s:3:" am";s:3:"256";s:3:" es";s:3:"257";s:4:" há";s:3:"258";s:3:" ny";s:3:"259";s:4:" tö";s:3:"260";s:3:"aka";s:3:"261";s:3:"art";s:3:"262";s:4:"ató";s:3:"263";s:3:"azt";s:3:"264";s:3:"bbe";s:3:"265";s:3:"ber";s:3:"266";s:4:"ció";s:3:"267";s:3:"cso";s:3:"268";s:3:"em ";s:3:"269";s:3:"eti";s:3:"270";s:4:"eté";s:3:"271";s:3:"gal";s:3:"272";s:3:"i t";s:3:"273";s:3:"ini";s:3:"274";s:3:"ist";s:3:"275";s:3:"ja ";s:3:"276";s:3:"ker";s:3:"277";s:3:"ki ";s:3:"278";s:3:"kor";s:3:"279";s:3:"koz";s:3:"280";s:4:"l é";s:3:"281";s:4:"ljá";s:3:"282";s:3:"lye";s:3:"283";s:3:"n v";s:3:"284";s:3:"ni ";s:3:"285";s:4:"pál";s:3:"286";s:3:"ror";s:3:"287";s:4:"ról";s:3:"288";s:4:"rül";s:3:"289";s:3:"s c";s:3:"290";s:3:"s p";s:3:"291";s:3:"s s";s:3:"292";s:3:"s v";s:3:"293";s:3:"sok";s:3:"294";s:3:"t j";s:3:"295";s:3:"t t";s:3:"296";s:3:"tar";s:3:"297";s:3:"tel";s:3:"298";s:3:"vat";s:3:"299";}s:9:"icelandic";a:300:{s:4:"að ";s:1:"0";s:3:"um ";s:1:"1";s:4:" að";s:1:"2";s:3:"ir ";s:1:"3";s:4:"ið ";s:1:"4";s:3:"ur ";s:1:"5";s:3:" ve";s:1:"6";s:4:" í ";s:1:"7";s:3:"na ";s:1:"8";s:4:" á ";s:1:"9";s:3:" se";s:2:"10";s:3:" er";s:2:"11";s:3:" og";s:2:"12";s:3:"ar ";s:2:"13";s:3:"og ";s:2:"14";s:3:"ver";s:2:"15";s:3:" mi";s:2:"16";s:3:"inn";s:2:"17";s:3:"nn ";s:2:"18";s:3:" fy";s:2:"19";s:3:"er ";s:2:"20";s:3:"fyr";s:2:"21";s:3:" ek";s:2:"22";s:3:" en";s:2:"23";s:3:" ha";s:2:"24";s:3:" he";s:2:"25";s:3:"ekk";s:2:"26";s:3:" st";s:2:"27";s:3:"ki ";s:2:"28";s:3:"st ";s:2:"29";s:4:"ði ";s:2:"30";s:3:" ba";s:2:"31";s:3:" me";s:2:"32";s:3:" vi";s:2:"33";s:3:"ig ";s:2:"34";s:3:"rir";s:2:"35";s:3:"yri";s:2:"36";s:3:" um";s:2:"37";s:3:"g f";s:2:"38";s:3:"leg";s:2:"39";s:3:"lei";s:2:"40";s:3:"ns ";s:2:"41";s:4:"ð s";s:2:"42";s:3:" ei";s:2:"43";s:4:" þa";s:2:"44";s:3:"in ";s:2:"45";s:3:"kki";s:2:"46";s:3:"r h";s:2:"47";s:3:"r s";s:2:"48";s:3:"egi";s:2:"49";s:3:"ein";s:2:"50";s:3:"ga ";s:2:"51";s:3:"ing";s:2:"52";s:3:"ra ";s:2:"53";s:3:"sta";s:2:"54";s:3:" va";s:2:"55";s:4:" þe";s:2:"56";s:3:"ann";s:2:"57";s:3:"en ";s:2:"58";s:3:"mil";s:2:"59";s:3:"sem";s:2:"60";s:4:"tjó";s:2:"61";s:4:"arð";s:2:"62";s:3:"di ";s:2:"63";s:3:"eit";s:2:"64";s:3:"haf";s:2:"65";s:3:"ill";s:2:"66";s:3:"ins";s:2:"67";s:3:"ist";s:2:"68";s:3:"llj";s:2:"69";s:3:"ndi";s:2:"70";s:3:"r a";s:2:"71";s:3:"r e";s:2:"72";s:3:"seg";s:2:"73";s:3:"un ";s:2:"74";s:3:"var";s:2:"75";s:3:" bi";s:2:"76";s:3:" el";s:2:"77";s:3:" fo";s:2:"78";s:3:" ge";s:2:"79";s:3:" yf";s:2:"80";s:3:"and";s:2:"81";s:3:"aug";s:2:"82";s:3:"bau";s:2:"83";s:3:"big";s:2:"84";s:3:"ega";s:2:"85";s:3:"eld";s:2:"86";s:4:"erð";s:2:"87";s:3:"fir";s:2:"88";s:3:"foo";s:2:"89";s:3:"gin";s:2:"90";s:3:"itt";s:2:"91";s:3:"n s";s:2:"92";s:3:"ngi";s:2:"93";s:3:"num";s:2:"94";s:3:"od ";s:2:"95";s:3:"ood";s:2:"96";s:3:"sin";s:2:"97";s:3:"ta ";s:2:"98";s:3:"tt ";s:2:"99";s:4:"við";s:3:"100";s:3:"yfi";s:3:"101";s:4:"ð e";s:3:"102";s:4:"ð f";s:3:"103";s:3:" hr";s:3:"104";s:4:" sé";s:3:"105";s:4:" þv";s:3:"106";s:3:"a e";s:3:"107";s:4:"a á";s:3:"108";s:3:"em ";s:3:"109";s:3:"gi ";s:3:"110";s:3:"i f";s:3:"111";s:3:"jar";s:3:"112";s:4:"jór";s:3:"113";s:3:"lja";s:3:"114";s:3:"m e";s:3:"115";s:4:"r á";s:3:"116";s:3:"rei";s:3:"117";s:3:"rst";s:3:"118";s:4:"rða";s:3:"119";s:4:"rði";s:3:"120";s:4:"rðu";s:3:"121";s:3:"stj";s:3:"122";s:3:"und";s:3:"123";s:3:"veg";s:3:"124";s:4:"ví ";s:3:"125";s:4:"ð v";s:3:"126";s:5:"það";s:3:"127";s:5:"því";s:3:"128";s:3:" fj";s:3:"129";s:3:" ko";s:3:"130";s:3:" sl";s:3:"131";s:3:"eik";s:3:"132";s:3:"end";s:3:"133";s:3:"ert";s:3:"134";s:3:"ess";s:3:"135";s:4:"fjá";s:3:"136";s:3:"fur";s:3:"137";s:3:"gir";s:3:"138";s:4:"hús";s:3:"139";s:4:"jár";s:3:"140";s:3:"n e";s:3:"141";s:3:"ri ";s:3:"142";s:3:"tar";s:3:"143";s:5:"ð þ";s:3:"144";s:4:"ðar";s:3:"145";s:4:"ður";s:3:"146";s:4:"þes";s:3:"147";s:3:" br";s:3:"148";s:4:" hú";s:3:"149";s:3:" kr";s:3:"150";s:3:" le";s:3:"151";s:3:" up";s:3:"152";s:3:"a s";s:3:"153";s:3:"egg";s:3:"154";s:3:"i s";s:3:"155";s:3:"irt";s:3:"156";s:3:"ja ";s:3:"157";s:4:"kið";s:3:"158";s:3:"len";s:3:"159";s:4:"með";s:3:"160";s:3:"mik";s:3:"161";s:3:"n b";s:3:"162";s:3:"nar";s:3:"163";s:3:"nir";s:3:"164";s:3:"nun";s:3:"165";s:3:"r f";s:3:"166";s:3:"r v";s:3:"167";s:4:"rið";s:3:"168";s:3:"rt ";s:3:"169";s:3:"sti";s:3:"170";s:3:"t v";s:3:"171";s:3:"ti ";s:3:"172";s:3:"una";s:3:"173";s:3:"upp";s:3:"174";s:4:"ða ";s:3:"175";s:4:"óna";s:3:"176";s:3:" al";s:3:"177";s:3:" fr";s:3:"178";s:3:" gr";s:3:"179";s:3:"a v";s:3:"180";s:3:"all";s:3:"181";s:3:"an ";s:3:"182";s:3:"da ";s:3:"183";s:4:"eið";s:3:"184";s:4:"eð ";s:3:"185";s:3:"fa ";s:3:"186";s:3:"fra";s:3:"187";s:3:"g e";s:3:"188";s:3:"ger";s:3:"189";s:4:"gið";s:3:"190";s:3:"gt ";s:3:"191";s:3:"han";s:3:"192";s:3:"hef";s:3:"193";s:3:"hel";s:3:"194";s:3:"her";s:3:"195";s:3:"hra";s:3:"196";s:3:"i a";s:3:"197";s:3:"i e";s:3:"198";s:3:"i v";s:3:"199";s:4:"i þ";s:3:"200";s:3:"iki";s:3:"201";s:4:"jón";s:3:"202";s:4:"jör";s:3:"203";s:3:"ka ";s:3:"204";s:4:"kró";s:3:"205";s:4:"lík";s:3:"206";s:3:"m h";s:3:"207";s:3:"n a";s:3:"208";s:3:"nga";s:3:"209";s:3:"r l";s:3:"210";s:3:"ram";s:3:"211";s:3:"ru ";s:3:"212";s:5:"ráð";s:3:"213";s:4:"rón";s:3:"214";s:3:"svo";s:3:"215";s:3:"vin";s:3:"216";s:4:"í b";s:3:"217";s:4:"í h";s:3:"218";s:4:"ð h";s:3:"219";s:4:"ð k";s:3:"220";s:4:"ð m";s:3:"221";s:5:"örð";s:3:"222";s:3:" af";s:3:"223";s:3:" fa";s:3:"224";s:4:" lí";s:3:"225";s:4:" rá";s:3:"226";s:3:" sk";s:3:"227";s:3:" sv";s:3:"228";s:3:" te";s:3:"229";s:3:"a b";s:3:"230";s:3:"a f";s:3:"231";s:3:"a h";s:3:"232";s:3:"a k";s:3:"233";s:3:"a u";s:3:"234";s:3:"afi";s:3:"235";s:3:"agn";s:3:"236";s:3:"arn";s:3:"237";s:3:"ast";s:3:"238";s:3:"ber";s:3:"239";s:3:"efu";s:3:"240";s:3:"enn";s:3:"241";s:3:"erb";s:3:"242";s:3:"erg";s:3:"243";s:3:"fi ";s:3:"244";s:3:"g a";s:3:"245";s:3:"gar";s:3:"246";s:4:"iðs";s:3:"247";s:3:"ker";s:3:"248";s:3:"kke";s:3:"249";s:3:"lan";s:3:"250";s:4:"ljó";s:3:"251";s:3:"llt";s:3:"252";s:3:"ma ";s:3:"253";s:4:"mið";s:3:"254";s:3:"n v";s:3:"255";s:4:"n í";s:3:"256";s:3:"nan";s:3:"257";s:3:"nda";s:3:"258";s:3:"ndu";s:3:"259";s:4:"nið";s:3:"260";s:3:"nna";s:3:"261";s:3:"nnu";s:3:"262";s:3:"nu ";s:3:"263";s:3:"r o";s:3:"264";s:3:"rbe";s:3:"265";s:3:"rgi";s:3:"266";s:4:"slö";s:3:"267";s:4:"sé ";s:3:"268";s:3:"t a";s:3:"269";s:3:"t h";s:3:"270";s:3:"til";s:3:"271";s:3:"tin";s:3:"272";s:3:"ugu";s:3:"273";s:3:"vil";s:3:"274";s:3:"ygg";s:3:"275";s:4:"á s";s:3:"276";s:4:"ð a";s:3:"277";s:4:"ð b";s:3:"278";s:4:"órn";s:3:"279";s:4:"ögn";s:3:"280";s:4:"öku";s:3:"281";s:3:" at";s:3:"282";s:3:" fi";s:3:"283";s:4:" fé";s:3:"284";s:3:" ka";s:3:"285";s:3:" ma";s:3:"286";s:3:" no";s:3:"287";s:3:" sa";s:3:"288";s:3:" si";s:3:"289";s:3:" ti";s:3:"290";s:4:" ák";s:3:"291";s:3:"a m";s:3:"292";s:3:"a t";s:3:"293";s:4:"a í";s:3:"294";s:4:"a þ";s:3:"295";s:3:"afa";s:3:"296";s:3:"afs";s:3:"297";s:3:"ald";s:3:"298";s:3:"arf";s:3:"299";}s:10:"indonesian";a:300:{s:3:"an ";s:1:"0";s:3:" me";s:1:"1";s:3:"kan";s:1:"2";s:3:"ang";s:1:"3";s:3:"ng ";s:1:"4";s:3:" pe";s:1:"5";s:3:"men";s:1:"6";s:3:" di";s:1:"7";s:3:" ke";s:1:"8";s:3:" da";s:1:"9";s:3:" se";s:2:"10";s:3:"eng";s:2:"11";s:3:" be";s:2:"12";s:3:"nga";s:2:"13";s:3:"nya";s:2:"14";s:3:" te";s:2:"15";s:3:"ah ";s:2:"16";s:3:"ber";s:2:"17";s:3:"aka";s:2:"18";s:3:" ya";s:2:"19";s:3:"dan";s:2:"20";s:3:"di ";s:2:"21";s:3:"yan";s:2:"22";s:3:"n p";s:2:"23";s:3:"per";s:2:"24";s:3:"a m";s:2:"25";s:3:"ita";s:2:"26";s:3:" pa";s:2:"27";s:3:"da ";s:2:"28";s:3:"ata";s:2:"29";s:3:"ada";s:2:"30";s:3:"ya ";s:2:"31";s:3:"ta ";s:2:"32";s:3:" in";s:2:"33";s:3:"ala";s:2:"34";s:3:"eri";s:2:"35";s:3:"ia ";s:2:"36";s:3:"a d";s:2:"37";s:3:"n k";s:2:"38";s:3:"am ";s:2:"39";s:3:"ga ";s:2:"40";s:3:"at ";s:2:"41";s:3:"era";s:2:"42";s:3:"n d";s:2:"43";s:3:"ter";s:2:"44";s:3:" ka";s:2:"45";s:3:"a p";s:2:"46";s:3:"ari";s:2:"47";s:3:"emb";s:2:"48";s:3:"n m";s:2:"49";s:3:"ri ";s:2:"50";s:3:" ba";s:2:"51";s:3:"aan";s:2:"52";s:3:"ak ";s:2:"53";s:3:"ra ";s:2:"54";s:3:" it";s:2:"55";s:3:"ara";s:2:"56";s:3:"ela";s:2:"57";s:3:"ni ";s:2:"58";s:3:"ali";s:2:"59";s:3:"ran";s:2:"60";s:3:"ar ";s:2:"61";s:3:"eru";s:2:"62";s:3:"lah";s:2:"63";s:3:"a b";s:2:"64";s:3:"asi";s:2:"65";s:3:"awa";s:2:"66";s:3:"eba";s:2:"67";s:3:"gan";s:2:"68";s:3:"n b";s:2:"69";s:3:" ha";s:2:"70";s:3:"ini";s:2:"71";s:3:"mer";s:2:"72";s:3:" la";s:2:"73";s:3:" mi";s:2:"74";s:3:"and";s:2:"75";s:3:"ena";s:2:"76";s:3:"wan";s:2:"77";s:3:" sa";s:2:"78";s:3:"aha";s:2:"79";s:3:"lam";s:2:"80";s:3:"n i";s:2:"81";s:3:"nda";s:2:"82";s:3:" wa";s:2:"83";s:3:"a i";s:2:"84";s:3:"dua";s:2:"85";s:3:"g m";s:2:"86";s:3:"mi ";s:2:"87";s:3:"n a";s:2:"88";s:3:"rus";s:2:"89";s:3:"tel";s:2:"90";s:3:"yak";s:2:"91";s:3:" an";s:2:"92";s:3:"dal";s:2:"93";s:3:"h d";s:2:"94";s:3:"i s";s:2:"95";s:3:"ing";s:2:"96";s:3:"min";s:2:"97";s:3:"ngg";s:2:"98";s:3:"tak";s:2:"99";s:3:"ami";s:3:"100";s:3:"beb";s:3:"101";s:3:"den";s:3:"102";s:3:"gat";s:3:"103";s:3:"ian";s:3:"104";s:3:"ih ";s:3:"105";s:3:"pad";s:3:"106";s:3:"rga";s:3:"107";s:3:"san";s:3:"108";s:3:"ua ";s:3:"109";s:3:" de";s:3:"110";s:3:"a t";s:3:"111";s:3:"arg";s:3:"112";s:3:"dar";s:3:"113";s:3:"elu";s:3:"114";s:3:"har";s:3:"115";s:3:"i k";s:3:"116";s:3:"i m";s:3:"117";s:3:"i p";s:3:"118";s:3:"ika";s:3:"119";s:3:"in ";s:3:"120";s:3:"iny";s:3:"121";s:3:"itu";s:3:"122";s:3:"mba";s:3:"123";s:3:"n t";s:3:"124";s:3:"ntu";s:3:"125";s:3:"pan";s:3:"126";s:3:"pen";s:3:"127";s:3:"sah";s:3:"128";s:3:"tan";s:3:"129";s:3:"tu ";s:3:"130";s:3:"a k";s:3:"131";s:3:"ban";s:3:"132";s:3:"edu";s:3:"133";s:3:"eka";s:3:"134";s:3:"g d";s:3:"135";s:3:"ka ";s:3:"136";s:3:"ker";s:3:"137";s:3:"nde";s:3:"138";s:3:"nta";s:3:"139";s:3:"ora";s:3:"140";s:3:"usa";s:3:"141";s:3:" du";s:3:"142";s:3:" ma";s:3:"143";s:3:"a s";s:3:"144";s:3:"ai ";s:3:"145";s:3:"ant";s:3:"146";s:3:"bas";s:3:"147";s:3:"end";s:3:"148";s:3:"i d";s:3:"149";s:3:"ira";s:3:"150";s:3:"kam";s:3:"151";s:3:"lan";s:3:"152";s:3:"n s";s:3:"153";s:3:"uli";s:3:"154";s:3:"al ";s:3:"155";s:3:"apa";s:3:"156";s:3:"ere";s:3:"157";s:3:"ert";s:3:"158";s:3:"lia";s:3:"159";s:3:"mem";s:3:"160";s:3:"rka";s:3:"161";s:3:"si ";s:3:"162";s:3:"tal";s:3:"163";s:3:"ung";s:3:"164";s:3:" ak";s:3:"165";s:3:"a a";s:3:"166";s:3:"a w";s:3:"167";s:3:"ani";s:3:"168";s:3:"ask";s:3:"169";s:3:"ent";s:3:"170";s:3:"gar";s:3:"171";s:3:"haa";s:3:"172";s:3:"i i";s:3:"173";s:3:"isa";s:3:"174";s:3:"ked";s:3:"175";s:3:"mbe";s:3:"176";s:3:"ska";s:3:"177";s:3:"tor";s:3:"178";s:3:"uan";s:3:"179";s:3:"uk ";s:3:"180";s:3:"uka";s:3:"181";s:3:" ad";s:3:"182";s:3:" to";s:3:"183";s:3:"asa";s:3:"184";s:3:"aya";s:3:"185";s:3:"bag";s:3:"186";s:3:"dia";s:3:"187";s:3:"dun";s:3:"188";s:3:"erj";s:3:"189";s:3:"mas";s:3:"190";s:3:"na ";s:3:"191";s:3:"rek";s:3:"192";s:3:"rit";s:3:"193";s:3:"sih";s:3:"194";s:3:"us ";s:3:"195";s:3:" bi";s:3:"196";s:3:"a h";s:3:"197";s:3:"ama";s:3:"198";s:3:"dib";s:3:"199";s:3:"ers";s:3:"200";s:3:"g s";s:3:"201";s:3:"han";s:3:"202";s:3:"ik ";s:3:"203";s:3:"kem";s:3:"204";s:3:"ma ";s:3:"205";s:3:"n l";s:3:"206";s:3:"nit";s:3:"207";s:3:"r b";s:3:"208";s:3:"rja";s:3:"209";s:3:"sa ";s:3:"210";s:3:" ju";s:3:"211";s:3:" or";s:3:"212";s:3:" si";s:3:"213";s:3:" ti";s:3:"214";s:3:"a y";s:3:"215";s:3:"aga";s:3:"216";s:3:"any";s:3:"217";s:3:"as ";s:3:"218";s:3:"cul";s:3:"219";s:3:"eme";s:3:"220";s:3:"emu";s:3:"221";s:3:"eny";s:3:"222";s:3:"epa";s:3:"223";s:3:"erb";s:3:"224";s:3:"erl";s:3:"225";s:3:"gi ";s:3:"226";s:3:"h m";s:3:"227";s:3:"i a";s:3:"228";s:3:"kel";s:3:"229";s:3:"li ";s:3:"230";s:3:"mel";s:3:"231";s:3:"nia";s:3:"232";s:3:"opa";s:3:"233";s:3:"rta";s:3:"234";s:3:"sia";s:3:"235";s:3:"tah";s:3:"236";s:3:"ula";s:3:"237";s:3:"un ";s:3:"238";s:3:"unt";s:3:"239";s:3:" at";s:3:"240";s:3:" bu";s:3:"241";s:3:" pu";s:3:"242";s:3:" ta";s:3:"243";s:3:"agi";s:3:"244";s:3:"alu";s:3:"245";s:3:"amb";s:3:"246";s:3:"bah";s:3:"247";s:3:"bis";s:3:"248";s:3:"er ";s:3:"249";s:3:"i t";s:3:"250";s:3:"ibe";s:3:"251";s:3:"ir ";s:3:"252";s:3:"ja ";s:3:"253";s:3:"k m";s:3:"254";s:3:"kar";s:3:"255";s:3:"lai";s:3:"256";s:3:"lal";s:3:"257";s:3:"lu ";s:3:"258";s:3:"mpa";s:3:"259";s:3:"ngk";s:3:"260";s:3:"nja";s:3:"261";s:3:"or ";s:3:"262";s:3:"pa ";s:3:"263";s:3:"pas";s:3:"264";s:3:"pem";s:3:"265";s:3:"rak";s:3:"266";s:3:"rik";s:3:"267";s:3:"seb";s:3:"268";s:3:"tam";s:3:"269";s:3:"tem";s:3:"270";s:3:"top";s:3:"271";s:3:"tuk";s:3:"272";s:3:"uni";s:3:"273";s:3:"war";s:3:"274";s:3:" al";s:3:"275";s:3:" ga";s:3:"276";s:3:" ge";s:3:"277";s:3:" ir";s:3:"278";s:3:" ja";s:3:"279";s:3:" mu";s:3:"280";s:3:" na";s:3:"281";s:3:" pr";s:3:"282";s:3:" su";s:3:"283";s:3:" un";s:3:"284";s:3:"ad ";s:3:"285";s:3:"adi";s:3:"286";s:3:"akt";s:3:"287";s:3:"ann";s:3:"288";s:3:"apo";s:3:"289";s:3:"bel";s:3:"290";s:3:"bul";s:3:"291";s:3:"der";s:3:"292";s:3:"ega";s:3:"293";s:3:"eke";s:3:"294";s:3:"ema";s:3:"295";s:3:"emp";s:3:"296";s:3:"ene";s:3:"297";s:3:"enj";s:3:"298";s:3:"esa";s:3:"299";}s:7:"italian";a:300:{s:3:" di";s:1:"0";s:3:"to ";s:1:"1";s:3:"la ";s:1:"2";s:3:" de";s:1:"3";s:3:"di ";s:1:"4";s:3:"no ";s:1:"5";s:3:" co";s:1:"6";s:3:"re ";s:1:"7";s:3:"ion";s:1:"8";s:3:"e d";s:1:"9";s:3:" e ";s:2:"10";s:3:"le ";s:2:"11";s:3:"del";s:2:"12";s:3:"ne ";s:2:"13";s:3:"ti ";s:2:"14";s:3:"ell";s:2:"15";s:3:" la";s:2:"16";s:3:" un";s:2:"17";s:3:"ni ";s:2:"18";s:3:"i d";s:2:"19";s:3:"per";s:2:"20";s:3:" pe";s:2:"21";s:3:"ent";s:2:"22";s:3:" in";s:2:"23";s:3:"one";s:2:"24";s:3:"he ";s:2:"25";s:3:"ta ";s:2:"26";s:3:"zio";s:2:"27";s:3:"che";s:2:"28";s:3:"o d";s:2:"29";s:3:"a d";s:2:"30";s:3:"na ";s:2:"31";s:3:"ato";s:2:"32";s:3:"e s";s:2:"33";s:3:" so";s:2:"34";s:3:"i s";s:2:"35";s:3:"lla";s:2:"36";s:3:"a p";s:2:"37";s:3:"li ";s:2:"38";s:3:"te ";s:2:"39";s:3:" al";s:2:"40";s:3:" ch";s:2:"41";s:3:"er ";s:2:"42";s:3:" pa";s:2:"43";s:3:" si";s:2:"44";s:3:"con";s:2:"45";s:3:"sta";s:2:"46";s:3:" pr";s:2:"47";s:3:"a c";s:2:"48";s:3:" se";s:2:"49";s:3:"el ";s:2:"50";s:3:"ia ";s:2:"51";s:3:"si ";s:2:"52";s:3:"e p";s:2:"53";s:3:" da";s:2:"54";s:3:"e i";s:2:"55";s:3:"i p";s:2:"56";s:3:"ont";s:2:"57";s:3:"ano";s:2:"58";s:3:"i c";s:2:"59";s:3:"all";s:2:"60";s:3:"azi";s:2:"61";s:3:"nte";s:2:"62";s:3:"on ";s:2:"63";s:3:"nti";s:2:"64";s:3:"o s";s:2:"65";s:3:" ri";s:2:"66";s:3:"i a";s:2:"67";s:3:"o a";s:2:"68";s:3:"un ";s:2:"69";s:3:" an";s:2:"70";s:3:"are";s:2:"71";s:3:"ari";s:2:"72";s:3:"e a";s:2:"73";s:3:"i e";s:2:"74";s:3:"ita";s:2:"75";s:3:"men";s:2:"76";s:3:"ri ";s:2:"77";s:3:" ca";s:2:"78";s:3:" il";s:2:"79";s:3:" no";s:2:"80";s:3:" po";s:2:"81";s:3:"a s";s:2:"82";s:3:"ant";s:2:"83";s:3:"il ";s:2:"84";s:3:"in ";s:2:"85";s:3:"a l";s:2:"86";s:3:"ati";s:2:"87";s:3:"cia";s:2:"88";s:3:"e c";s:2:"89";s:3:"ro ";s:2:"90";s:3:"ann";s:2:"91";s:3:"est";s:2:"92";s:3:"gli";s:2:"93";s:4:"tà ";s:2:"94";s:3:" qu";s:2:"95";s:3:"e l";s:2:"96";s:3:"nta";s:2:"97";s:3:" a ";s:2:"98";s:3:"com";s:2:"99";s:3:"o c";s:3:"100";s:3:"ra ";s:3:"101";s:3:" le";s:3:"102";s:3:" ne";s:3:"103";s:3:"ali";s:3:"104";s:3:"ere";s:3:"105";s:3:"ist";s:3:"106";s:3:" ma";s:3:"107";s:4:" è ";s:3:"108";s:3:"io ";s:3:"109";s:3:"lle";s:3:"110";s:3:"me ";s:3:"111";s:3:"era";s:3:"112";s:3:"ica";s:3:"113";s:3:"ost";s:3:"114";s:3:"pro";s:3:"115";s:3:"tar";s:3:"116";s:3:"una";s:3:"117";s:3:" pi";s:3:"118";s:3:"da ";s:3:"119";s:3:"tat";s:3:"120";s:3:" mi";s:3:"121";s:3:"att";s:3:"122";s:3:"ca ";s:3:"123";s:3:"mo ";s:3:"124";s:3:"non";s:3:"125";s:3:"par";s:3:"126";s:3:"sti";s:3:"127";s:3:" fa";s:3:"128";s:3:" i ";s:3:"129";s:3:" re";s:3:"130";s:3:" su";s:3:"131";s:3:"ess";s:3:"132";s:3:"ini";s:3:"133";s:3:"nto";s:3:"134";s:3:"o l";s:3:"135";s:3:"ssi";s:3:"136";s:3:"tto";s:3:"137";s:3:"a e";s:3:"138";s:3:"ame";s:3:"139";s:3:"col";s:3:"140";s:3:"ei ";s:3:"141";s:3:"ma ";s:3:"142";s:3:"o i";s:3:"143";s:3:"za ";s:3:"144";s:3:" st";s:3:"145";s:3:"a a";s:3:"146";s:3:"ale";s:3:"147";s:3:"anc";s:3:"148";s:3:"ani";s:3:"149";s:3:"i m";s:3:"150";s:3:"ian";s:3:"151";s:3:"o p";s:3:"152";s:3:"oni";s:3:"153";s:3:"sio";s:3:"154";s:3:"tan";s:3:"155";s:3:"tti";s:3:"156";s:3:" lo";s:3:"157";s:3:"i r";s:3:"158";s:3:"oci";s:3:"159";s:3:"oli";s:3:"160";s:3:"ona";s:3:"161";s:3:"ono";s:3:"162";s:3:"tra";s:3:"163";s:3:" l ";s:3:"164";s:3:"a r";s:3:"165";s:3:"eri";s:3:"166";s:3:"ett";s:3:"167";s:3:"lo ";s:3:"168";s:3:"nza";s:3:"169";s:3:"que";s:3:"170";s:3:"str";s:3:"171";s:3:"ter";s:3:"172";s:3:"tta";s:3:"173";s:3:" ba";s:3:"174";s:3:" li";s:3:"175";s:3:" te";s:3:"176";s:3:"ass";s:3:"177";s:3:"e f";s:3:"178";s:3:"enz";s:3:"179";s:3:"for";s:3:"180";s:3:"nno";s:3:"181";s:3:"olo";s:3:"182";s:3:"ori";s:3:"183";s:3:"res";s:3:"184";s:3:"tor";s:3:"185";s:3:" ci";s:3:"186";s:3:" vo";s:3:"187";s:3:"a i";s:3:"188";s:3:"al ";s:3:"189";s:3:"chi";s:3:"190";s:3:"e n";s:3:"191";s:3:"lia";s:3:"192";s:3:"pre";s:3:"193";s:3:"ria";s:3:"194";s:3:"uni";s:3:"195";s:3:"ver";s:3:"196";s:3:" sp";s:3:"197";s:3:"imo";s:3:"198";s:3:"l a";s:3:"199";s:3:"l c";s:3:"200";s:3:"ran";s:3:"201";s:3:"sen";s:3:"202";s:3:"soc";s:3:"203";s:3:"tic";s:3:"204";s:3:" fi";s:3:"205";s:3:" mo";s:3:"206";s:3:"a n";s:3:"207";s:3:"ce ";s:3:"208";s:3:"dei";s:3:"209";s:3:"ggi";s:3:"210";s:3:"gio";s:3:"211";s:3:"iti";s:3:"212";s:3:"l s";s:3:"213";s:3:"lit";s:3:"214";s:3:"ll ";s:3:"215";s:3:"mon";s:3:"216";s:3:"ola";s:3:"217";s:3:"pac";s:3:"218";s:3:"sim";s:3:"219";s:3:"tit";s:3:"220";s:3:"utt";s:3:"221";s:3:"vol";s:3:"222";s:3:" ar";s:3:"223";s:3:" fo";s:3:"224";s:3:" ha";s:3:"225";s:3:" sa";s:3:"226";s:3:"acc";s:3:"227";s:3:"e r";s:3:"228";s:3:"ire";s:3:"229";s:3:"man";s:3:"230";s:3:"ntr";s:3:"231";s:3:"rat";s:3:"232";s:3:"sco";s:3:"233";s:3:"tro";s:3:"234";s:3:"tut";s:3:"235";s:3:"va ";s:3:"236";s:3:" do";s:3:"237";s:3:" gi";s:3:"238";s:3:" me";s:3:"239";s:3:" sc";s:3:"240";s:3:" tu";s:3:"241";s:3:" ve";s:3:"242";s:3:" vi";s:3:"243";s:3:"a m";s:3:"244";s:3:"ber";s:3:"245";s:3:"can";s:3:"246";s:3:"cit";s:3:"247";s:3:"i l";s:3:"248";s:3:"ier";s:3:"249";s:4:"ità";s:3:"250";s:3:"lli";s:3:"251";s:3:"min";s:3:"252";s:3:"n p";s:3:"253";s:3:"nat";s:3:"254";s:3:"nda";s:3:"255";s:3:"o e";s:3:"256";s:3:"o f";s:3:"257";s:3:"o u";s:3:"258";s:3:"ore";s:3:"259";s:3:"oro";s:3:"260";s:3:"ort";s:3:"261";s:3:"sto";s:3:"262";s:3:"ten";s:3:"263";s:3:"tiv";s:3:"264";s:3:"van";s:3:"265";s:3:"art";s:3:"266";s:3:"cco";s:3:"267";s:3:"ci ";s:3:"268";s:3:"cos";s:3:"269";s:3:"dal";s:3:"270";s:3:"e v";s:3:"271";s:3:"i i";s:3:"272";s:3:"ila";s:3:"273";s:3:"ino";s:3:"274";s:3:"l p";s:3:"275";s:3:"n c";s:3:"276";s:3:"nit";s:3:"277";s:3:"ole";s:3:"278";s:3:"ome";s:3:"279";s:3:"po ";s:3:"280";s:3:"rio";s:3:"281";s:3:"sa ";s:3:"282";s:3:" ce";s:3:"283";s:3:" es";s:3:"284";s:3:" tr";s:3:"285";s:3:"a b";s:3:"286";s:3:"and";s:3:"287";s:3:"ata";s:3:"288";s:3:"der";s:3:"289";s:3:"ens";s:3:"290";s:3:"ers";s:3:"291";s:3:"gi ";s:3:"292";s:3:"ial";s:3:"293";s:3:"ina";s:3:"294";s:3:"itt";s:3:"295";s:3:"izi";s:3:"296";s:3:"lan";s:3:"297";s:3:"lor";s:3:"298";s:3:"mil";s:3:"299";}s:6:"kazakh";a:300:{s:5:"ан ";s:1:"0";s:5:"ен ";s:1:"1";s:5:"ың ";s:1:"2";s:5:" қа";s:1:"3";s:5:" ба";s:1:"4";s:5:"ай ";s:1:"5";s:6:"нда";s:1:"6";s:5:"ын ";s:1:"7";s:5:" са";s:1:"8";s:5:" ал";s:1:"9";s:5:"ді ";s:2:"10";s:6:"ары";s:2:"11";s:5:"ды ";s:2:"12";s:5:"ып ";s:2:"13";s:5:" мұ";s:2:"14";s:5:" бі";s:2:"15";s:6:"асы";s:2:"16";s:5:"да ";s:2:"17";s:6:"най";s:2:"18";s:5:" жа";s:2:"19";s:6:"мұн";s:2:"20";s:6:"ста";s:2:"21";s:6:"ған";s:2:"22";s:5:"н б";s:2:"23";s:6:"ұна";s:2:"24";s:5:" бо";s:2:"25";s:6:"ның";s:2:"26";s:5:"ін ";s:2:"27";s:6:"лар";s:2:"28";s:6:"сын";s:2:"29";s:5:" де";s:2:"30";s:6:"аға";s:2:"31";s:6:"тан";s:2:"32";s:5:" кө";s:2:"33";s:6:"бір";s:2:"34";s:5:"ер ";s:2:"35";s:6:"мен";s:2:"36";s:6:"аза";s:2:"37";s:6:"ынд";s:2:"38";s:6:"ыны";s:2:"39";s:5:" ме";s:2:"40";s:6:"анд";s:2:"41";s:6:"ері";s:2:"42";s:6:"бол";s:2:"43";s:6:"дың";s:2:"44";s:6:"қаз";s:2:"45";s:6:"аты";s:2:"46";s:5:"сы ";s:2:"47";s:6:"тын";s:2:"48";s:5:"ғы ";s:2:"49";s:5:" ке";s:2:"50";s:5:"ар ";s:2:"51";s:6:"зақ";s:2:"52";s:5:"ық ";s:2:"53";s:6:"ала";s:2:"54";s:6:"алы";s:2:"55";s:6:"аны";s:2:"56";s:6:"ара";s:2:"57";s:6:"ағы";s:2:"58";s:6:"ген";s:2:"59";s:6:"тар";s:2:"60";s:6:"тер";s:2:"61";s:6:"тыр";s:2:"62";s:6:"айд";s:2:"63";s:6:"ард";s:2:"64";s:5:"де ";s:2:"65";s:5:"ға ";s:2:"66";s:5:" қо";s:2:"67";s:6:"бар";s:2:"68";s:5:"ің ";s:2:"69";s:6:"қан";s:2:"70";s:5:" бе";s:2:"71";s:5:" қы";s:2:"72";s:6:"ақс";s:2:"73";s:6:"гер";s:2:"74";s:6:"дан";s:2:"75";s:6:"дар";s:2:"76";s:6:"лық";s:2:"77";s:6:"лға";s:2:"78";s:6:"ына";s:2:"79";s:5:"ір ";s:2:"80";s:6:"ірі";s:2:"81";s:6:"ғас";s:2:"82";s:5:" та";s:2:"83";s:5:"а б";s:2:"84";s:5:"гі ";s:2:"85";s:6:"еді";s:2:"86";s:6:"еле";s:2:"87";s:6:"йды";s:2:"88";s:5:"н к";s:2:"89";s:5:"н т";s:2:"90";s:6:"ола";s:2:"91";s:6:"рын";s:2:"92";s:5:"іп ";s:2:"93";s:6:"қст";s:2:"94";s:6:"қта";s:2:"95";s:5:"ң б";s:2:"96";s:5:" ай";s:2:"97";s:5:" ол";s:2:"98";s:5:" со";s:2:"99";s:6:"айт";s:3:"100";s:6:"дағ";s:3:"101";s:6:"иге";s:3:"102";s:6:"лер";s:3:"103";s:6:"лып";s:3:"104";s:5:"н а";s:3:"105";s:5:"ік ";s:3:"106";s:6:"ақт";s:3:"107";s:6:"бағ";s:3:"108";s:6:"кен";s:3:"109";s:5:"н қ";s:3:"110";s:5:"ны ";s:3:"111";s:6:"рге";s:3:"112";s:6:"рға";s:3:"113";s:5:"ыр ";s:3:"114";s:5:" ар";s:3:"115";s:6:"алғ";s:3:"116";s:6:"аса";s:3:"117";s:6:"бас";s:3:"118";s:6:"бер";s:3:"119";s:5:"ге ";s:3:"120";s:6:"еті";s:3:"121";s:5:"на ";s:3:"122";s:6:"нде";s:3:"123";s:5:"не ";s:3:"124";s:6:"ниг";s:3:"125";s:6:"рды";s:3:"126";s:5:"ры ";s:3:"127";s:6:"сай";s:3:"128";s:5:" ау";s:3:"129";s:5:" кү";s:3:"130";s:5:" ни";s:3:"131";s:5:" от";s:3:"132";s:5:" өз";s:3:"133";s:6:"ауд";s:3:"134";s:5:"еп ";s:3:"135";s:6:"иял";s:3:"136";s:6:"лты";s:3:"137";s:5:"н ж";s:3:"138";s:5:"н о";s:3:"139";s:6:"осы";s:3:"140";s:6:"оты";s:3:"141";s:6:"рып";s:3:"142";s:5:"рі ";s:3:"143";s:6:"тке";s:3:"144";s:5:"ты ";s:3:"145";s:5:"ы б";s:3:"146";s:5:"ы ж";s:3:"147";s:6:"ылы";s:3:"148";s:6:"ысы";s:3:"149";s:5:"і с";s:3:"150";s:6:"қар";s:3:"151";s:5:" бұ";s:3:"152";s:5:" да";s:3:"153";s:5:" же";s:3:"154";s:5:" тұ";s:3:"155";s:5:" құ";s:3:"156";s:6:"ады";s:3:"157";s:6:"айл";s:3:"158";s:5:"ап ";s:3:"159";s:6:"ата";s:3:"160";s:6:"ені";s:3:"161";s:6:"йла";s:3:"162";s:5:"н м";s:3:"163";s:5:"н с";s:3:"164";s:6:"нды";s:3:"165";s:6:"нді";s:3:"166";s:5:"р м";s:3:"167";s:6:"тай";s:3:"168";s:6:"тін";s:3:"169";s:5:"ы т";s:3:"170";s:5:"ыс ";s:3:"171";s:6:"інд";s:3:"172";s:5:" би";s:3:"173";s:5:"а ж";s:3:"174";s:6:"ауы";s:3:"175";s:6:"деп";s:3:"176";s:6:"дің";s:3:"177";s:6:"еке";s:3:"178";s:6:"ери";s:3:"179";s:6:"йын";s:3:"180";s:6:"кел";s:3:"181";s:6:"лды";s:3:"182";s:5:"ма ";s:3:"183";s:6:"нан";s:3:"184";s:6:"оны";s:3:"185";s:5:"п ж";s:3:"186";s:5:"п о";s:3:"187";s:5:"р б";s:3:"188";s:6:"рия";s:3:"189";s:6:"рла";s:3:"190";s:6:"уда";s:3:"191";s:6:"шыл";s:3:"192";s:5:"ы а";s:3:"193";s:6:"ықт";s:3:"194";s:5:"і а";s:3:"195";s:5:"і б";s:3:"196";s:5:"із ";s:3:"197";s:6:"ілі";s:3:"198";s:5:"ң қ";s:3:"199";s:5:" ас";s:3:"200";s:5:" ек";s:3:"201";s:5:" жо";s:3:"202";s:5:" мә";s:3:"203";s:5:" ос";s:3:"204";s:5:" ре";s:3:"205";s:5:" се";s:3:"206";s:6:"алд";s:3:"207";s:6:"дал";s:3:"208";s:6:"дег";s:3:"209";s:6:"дей";s:3:"210";s:5:"е б";s:3:"211";s:5:"ет ";s:3:"212";s:6:"жас";s:3:"213";s:5:"й б";s:3:"214";s:6:"лау";s:3:"215";s:6:"лда";s:3:"216";s:6:"мет";s:3:"217";s:6:"нын";s:3:"218";s:6:"сар";s:3:"219";s:5:"сі ";s:3:"220";s:5:"ті ";s:3:"221";s:6:"ыры";s:3:"222";s:6:"ыта";s:3:"223";s:6:"ісі";s:3:"224";s:5:"ң а";s:3:"225";s:6:"өте";s:3:"226";s:5:" ат";s:3:"227";s:5:" ел";s:3:"228";s:5:" жү";s:3:"229";s:5:" ма";s:3:"230";s:5:" то";s:3:"231";s:5:" шы";s:3:"232";s:5:"а а";s:3:"233";s:6:"алт";s:3:"234";s:6:"ама";s:3:"235";s:6:"арл";s:3:"236";s:6:"аст";s:3:"237";s:6:"бұл";s:3:"238";s:6:"дай";s:3:"239";s:6:"дық";s:3:"240";s:5:"ек ";s:3:"241";s:6:"ель";s:3:"242";s:6:"есі";s:3:"243";s:6:"зді";s:3:"244";s:6:"көт";s:3:"245";s:6:"лем";s:3:"246";s:5:"ль ";s:3:"247";s:5:"н е";s:3:"248";s:5:"п а";s:3:"249";s:5:"р а";s:3:"250";s:6:"рес";s:3:"251";s:5:"са ";s:3:"252";s:5:"та ";s:3:"253";s:6:"тте";s:3:"254";s:6:"тұр";s:3:"255";s:5:"шы ";s:3:"256";s:5:"ы д";s:3:"257";s:5:"ы қ";s:3:"258";s:5:"ыз ";s:3:"259";s:6:"қыт";s:3:"260";s:5:" ко";s:3:"261";s:5:" не";s:3:"262";s:5:" ой";s:3:"263";s:5:" ор";s:3:"264";s:5:" сұ";s:3:"265";s:5:" тү";s:3:"266";s:6:"аль";s:3:"267";s:6:"аре";s:3:"268";s:6:"атт";s:3:"269";s:6:"дір";s:3:"270";s:5:"ев ";s:3:"271";s:6:"егі";s:3:"272";s:6:"еда";s:3:"273";s:6:"екі";s:3:"274";s:6:"елд";s:3:"275";s:6:"ерг";s:3:"276";s:6:"ерд";s:3:"277";s:6:"ияд";s:3:"278";s:6:"кер";s:3:"279";s:6:"кет";s:3:"280";s:6:"лыс";s:3:"281";s:6:"ліс";s:3:"282";s:6:"мед";s:3:"283";s:6:"мпи";s:3:"284";s:5:"н д";s:3:"285";s:5:"ні ";s:3:"286";s:6:"нін";s:3:"287";s:5:"п т";s:3:"288";s:6:"пек";s:3:"289";s:6:"рел";s:3:"290";s:6:"рта";s:3:"291";s:6:"ріл";s:3:"292";s:6:"рін";s:3:"293";s:6:"сен";s:3:"294";s:6:"тал";s:3:"295";s:6:"шіл";s:3:"296";s:5:"ы к";s:3:"297";s:5:"ы м";s:3:"298";s:6:"ыст";s:3:"299";}s:6:"kyrgyz";a:300:{s:5:"ын ";s:1:"0";s:5:"ан ";s:1:"1";s:5:" жа";s:1:"2";s:5:"ен ";s:1:"3";s:5:"да ";s:1:"4";s:5:" та";s:1:"5";s:5:"ар ";s:1:"6";s:5:"ин ";s:1:"7";s:5:" ка";s:1:"8";s:6:"ары";s:1:"9";s:5:" ал";s:2:"10";s:5:" ба";s:2:"11";s:5:" би";s:2:"12";s:6:"лар";s:2:"13";s:5:" бо";s:2:"14";s:5:" кы";s:2:"15";s:6:"ала";s:2:"16";s:5:"н к";s:2:"17";s:5:" са";s:2:"18";s:6:"нда";s:2:"19";s:6:"ган";s:2:"20";s:6:"тар";s:2:"21";s:5:" де";s:2:"22";s:6:"анд";s:2:"23";s:5:"н б";s:2:"24";s:5:" ке";s:2:"25";s:6:"ард";s:2:"26";s:6:"мен";s:2:"27";s:5:"н т";s:2:"28";s:6:"ара";s:2:"29";s:6:"нын";s:2:"30";s:5:" да";s:2:"31";s:5:" ме";s:2:"32";s:6:"кыр";s:2:"33";s:5:" че";s:2:"34";s:5:"н а";s:2:"35";s:5:"ры ";s:2:"36";s:5:" ко";s:2:"37";s:6:"ген";s:2:"38";s:6:"дар";s:2:"39";s:6:"кен";s:2:"40";s:6:"кта";s:2:"41";s:5:"уу ";s:2:"42";s:6:"ене";s:2:"43";s:6:"ери";s:2:"44";s:5:" ша";s:2:"45";s:6:"алы";s:2:"46";s:5:"ат ";s:2:"47";s:5:"на ";s:2:"48";s:5:" кө";s:2:"49";s:5:" эм";s:2:"50";s:6:"аты";s:2:"51";s:6:"дан";s:2:"52";s:6:"деп";s:2:"53";s:6:"дын";s:2:"54";s:5:"еп ";s:2:"55";s:6:"нен";s:2:"56";s:6:"рын";s:2:"57";s:5:" бе";s:2:"58";s:6:"кан";s:2:"59";s:6:"луу";s:2:"60";s:6:"ргы";s:2:"61";s:6:"тан";s:2:"62";s:6:"шай";s:2:"63";s:6:"ырг";s:2:"64";s:5:"үн ";s:2:"65";s:5:" ар";s:2:"66";s:5:" ма";s:2:"67";s:6:"агы";s:2:"68";s:6:"акт";s:2:"69";s:6:"аны";s:2:"70";s:5:"гы ";s:2:"71";s:6:"гыз";s:2:"72";s:5:"ды ";s:2:"73";s:6:"рда";s:2:"74";s:5:"ай ";s:2:"75";s:6:"бир";s:2:"76";s:6:"бол";s:2:"77";s:5:"ер ";s:2:"78";s:5:"н с";s:2:"79";s:6:"нды";s:2:"80";s:5:"ун ";s:2:"81";s:5:"ча ";s:2:"82";s:6:"ынд";s:2:"83";s:5:"а к";s:2:"84";s:6:"ага";s:2:"85";s:6:"айл";s:2:"86";s:6:"ана";s:2:"87";s:5:"ап ";s:2:"88";s:5:"га ";s:2:"89";s:6:"лге";s:2:"90";s:6:"нча";s:2:"91";s:5:"п к";s:2:"92";s:6:"рды";s:2:"93";s:6:"туу";s:2:"94";s:6:"ыны";s:2:"95";s:5:" ан";s:2:"96";s:5:" өз";s:2:"97";s:6:"ама";s:2:"98";s:6:"ата";s:2:"99";s:6:"дин";s:3:"100";s:5:"йт ";s:3:"101";s:6:"лга";s:3:"102";s:6:"лоо";s:3:"103";s:5:"оо ";s:3:"104";s:5:"ри ";s:3:"105";s:6:"тин";s:3:"106";s:5:"ыз ";s:3:"107";s:5:"ып ";s:3:"108";s:6:"өрү";s:3:"109";s:5:" па";s:3:"110";s:5:" эк";s:3:"111";s:5:"а б";s:3:"112";s:6:"алг";s:3:"113";s:6:"асы";s:3:"114";s:6:"ашт";s:3:"115";s:6:"биз";s:3:"116";s:6:"кел";s:3:"117";s:6:"кте";s:3:"118";s:6:"тал";s:3:"119";s:5:" не";s:3:"120";s:5:" су";s:3:"121";s:6:"акы";s:3:"122";s:6:"ент";s:3:"123";s:6:"инд";s:3:"124";s:5:"ир ";s:3:"125";s:6:"кал";s:3:"126";s:5:"н д";s:3:"127";s:6:"нде";s:3:"128";s:6:"ого";s:3:"129";s:6:"онд";s:3:"130";s:6:"оюн";s:3:"131";s:5:"р б";s:3:"132";s:5:"р м";s:3:"133";s:6:"ран";s:3:"134";s:6:"сал";s:3:"135";s:6:"ста";s:3:"136";s:5:"сы ";s:3:"137";s:6:"ура";s:3:"138";s:6:"ыгы";s:3:"139";s:5:" аш";s:3:"140";s:5:" ми";s:3:"141";s:5:" сы";s:3:"142";s:5:" ту";s:3:"143";s:5:"ал ";s:3:"144";s:6:"арт";s:3:"145";s:6:"бор";s:3:"146";s:6:"елг";s:3:"147";s:6:"ени";s:3:"148";s:5:"ет ";s:3:"149";s:6:"жат";s:3:"150";s:6:"йло";s:3:"151";s:6:"кар";s:3:"152";s:5:"н м";s:3:"153";s:6:"огу";s:3:"154";s:5:"п а";s:3:"155";s:5:"п ж";s:3:"156";s:5:"р э";s:3:"157";s:6:"сын";s:3:"158";s:5:"ык ";s:3:"159";s:6:"юнч";s:3:"160";s:5:" бу";s:3:"161";s:5:" ур";s:3:"162";s:5:"а а";s:3:"163";s:5:"ак ";s:3:"164";s:6:"алд";s:3:"165";s:6:"алу";s:3:"166";s:6:"бар";s:3:"167";s:6:"бер";s:3:"168";s:6:"бою";s:3:"169";s:5:"ге ";s:3:"170";s:6:"дон";s:3:"171";s:6:"еги";s:3:"172";s:6:"ект";s:3:"173";s:6:"ефт";s:3:"174";s:5:"из ";s:3:"175";s:6:"кат";s:3:"176";s:6:"лды";s:3:"177";s:5:"н ч";s:3:"178";s:5:"н э";s:3:"179";s:5:"н ө";s:3:"180";s:6:"ндо";s:3:"181";s:6:"неф";s:3:"182";s:5:"он ";s:3:"183";s:6:"сат";s:3:"184";s:6:"тор";s:3:"185";s:5:"ты ";s:3:"186";s:6:"уда";s:3:"187";s:5:"ул ";s:3:"188";s:6:"ула";s:3:"189";s:6:"ууд";s:3:"190";s:5:"ы б";s:3:"191";s:5:"ы ж";s:3:"192";s:5:"ы к";s:3:"193";s:5:"ыл ";s:3:"194";s:6:"ына";s:3:"195";s:6:"эке";s:3:"196";s:6:"ясы";s:3:"197";s:5:" ат";s:3:"198";s:5:" до";s:3:"199";s:5:" жы";s:3:"200";s:5:" со";s:3:"201";s:5:" чы";s:3:"202";s:6:"аас";s:3:"203";s:6:"айт";s:3:"204";s:6:"аст";s:3:"205";s:6:"баа";s:3:"206";s:6:"баш";s:3:"207";s:6:"гар";s:3:"208";s:6:"гын";s:3:"209";s:5:"дө ";s:3:"210";s:5:"е б";s:3:"211";s:5:"ек ";s:3:"212";s:6:"жыл";s:3:"213";s:5:"и б";s:3:"214";s:5:"ик ";s:3:"215";s:6:"ияс";s:3:"216";s:6:"кыз";s:3:"217";s:6:"лда";s:3:"218";s:6:"лык";s:3:"219";s:6:"мда";s:3:"220";s:5:"н ж";s:3:"221";s:6:"нди";s:3:"222";s:5:"ни ";s:3:"223";s:6:"нин";s:3:"224";s:6:"орд";s:3:"225";s:6:"рдо";s:3:"226";s:6:"сто";s:3:"227";s:5:"та ";s:3:"228";s:6:"тер";s:3:"229";s:6:"тти";s:3:"230";s:6:"тур";s:3:"231";s:6:"тын";s:3:"232";s:5:"уп ";s:3:"233";s:6:"ушу";s:3:"234";s:6:"фти";s:3:"235";s:6:"ыкт";s:3:"236";s:5:"үп ";s:3:"237";s:5:"өн ";s:3:"238";s:5:" ай";s:3:"239";s:5:" бү";s:3:"240";s:5:" ич";s:3:"241";s:5:" иш";s:3:"242";s:5:" мо";s:3:"243";s:5:" пр";s:3:"244";s:5:" ре";s:3:"245";s:5:" өк";s:3:"246";s:5:" өт";s:3:"247";s:5:"а д";s:3:"248";s:5:"а у";s:3:"249";s:5:"а э";s:3:"250";s:6:"айм";s:3:"251";s:6:"амд";s:3:"252";s:6:"атт";s:3:"253";s:6:"бек";s:3:"254";s:6:"бул";s:3:"255";s:6:"гол";s:3:"256";s:6:"дег";s:3:"257";s:6:"еге";s:3:"258";s:6:"ейт";s:3:"259";s:6:"еле";s:3:"260";s:6:"енд";s:3:"261";s:6:"жак";s:3:"262";s:5:"и к";s:3:"263";s:6:"ини";s:3:"264";s:6:"ири";s:3:"265";s:6:"йма";s:3:"266";s:6:"кто";s:3:"267";s:6:"лик";s:3:"268";s:6:"мак";s:3:"269";s:6:"мес";s:3:"270";s:5:"н у";s:3:"271";s:5:"н ш";s:3:"272";s:6:"нтт";s:3:"273";s:5:"ол ";s:3:"274";s:6:"оло";s:3:"275";s:6:"пар";s:3:"276";s:6:"рак";s:3:"277";s:6:"рүү";s:3:"278";s:6:"сыр";s:3:"279";s:5:"ти ";s:3:"280";s:6:"тик";s:3:"281";s:6:"тта";s:3:"282";s:6:"төр";s:3:"283";s:5:"у ж";s:3:"284";s:5:"у с";s:3:"285";s:6:"шка";s:3:"286";s:5:"ы м";s:3:"287";s:6:"ызы";s:3:"288";s:6:"ылд";s:3:"289";s:6:"эме";s:3:"290";s:6:"үрү";s:3:"291";s:6:"өлү";s:3:"292";s:6:"өтө";s:3:"293";s:5:" же";s:3:"294";s:5:" тү";s:3:"295";s:5:" эл";s:3:"296";s:5:" өн";s:3:"297";s:5:"а ж";s:3:"298";s:6:"ады";s:3:"299";}s:5:"latin";a:300:{s:3:"um ";s:1:"0";s:3:"us ";s:1:"1";s:3:"ut ";s:1:"2";s:3:"et ";s:1:"3";s:3:"is ";s:1:"4";s:3:" et";s:1:"5";s:3:" in";s:1:"6";s:3:" qu";s:1:"7";s:3:"tur";s:1:"8";s:3:" pr";s:1:"9";s:3:"est";s:2:"10";s:3:"tio";s:2:"11";s:3:" au";s:2:"12";s:3:"am ";s:2:"13";s:3:"em ";s:2:"14";s:3:"aut";s:2:"15";s:3:" di";s:2:"16";s:3:"ent";s:2:"17";s:3:"in ";s:2:"18";s:3:"dic";s:2:"19";s:3:"t e";s:2:"20";s:3:" es";s:2:"21";s:3:"ur ";s:2:"22";s:3:"ati";s:2:"23";s:3:"ion";s:2:"24";s:3:"st ";s:2:"25";s:3:" ut";s:2:"26";s:3:"ae ";s:2:"27";s:3:"qua";s:2:"28";s:3:" de";s:2:"29";s:3:"nt ";s:2:"30";s:3:" su";s:2:"31";s:3:" si";s:2:"32";s:3:"itu";s:2:"33";s:3:"unt";s:2:"34";s:3:"rum";s:2:"35";s:3:"ia ";s:2:"36";s:3:"es ";s:2:"37";s:3:"ter";s:2:"38";s:3:" re";s:2:"39";s:3:"nti";s:2:"40";s:3:"rae";s:2:"41";s:3:"s e";s:2:"42";s:3:"qui";s:2:"43";s:3:"io ";s:2:"44";s:3:"pro";s:2:"45";s:3:"it ";s:2:"46";s:3:"per";s:2:"47";s:3:"ita";s:2:"48";s:3:"one";s:2:"49";s:3:"ici";s:2:"50";s:3:"ius";s:2:"51";s:3:" co";s:2:"52";s:3:"t d";s:2:"53";s:3:"bus";s:2:"54";s:3:"pra";s:2:"55";s:3:"m e";s:2:"56";s:3:" no";s:2:"57";s:3:"edi";s:2:"58";s:3:"tia";s:2:"59";s:3:"ue ";s:2:"60";s:3:"ibu";s:2:"61";s:3:" se";s:2:"62";s:3:" ad";s:2:"63";s:3:"er ";s:2:"64";s:3:" fi";s:2:"65";s:3:"ili";s:2:"66";s:3:"que";s:2:"67";s:3:"t i";s:2:"68";s:3:"de ";s:2:"69";s:3:"oru";s:2:"70";s:3:" te";s:2:"71";s:3:"ali";s:2:"72";s:3:" pe";s:2:"73";s:3:"aed";s:2:"74";s:3:"cit";s:2:"75";s:3:"m d";s:2:"76";s:3:"t s";s:2:"77";s:3:"tat";s:2:"78";s:3:"tem";s:2:"79";s:3:"tis";s:2:"80";s:3:"t p";s:2:"81";s:3:"sti";s:2:"82";s:3:"te ";s:2:"83";s:3:"cum";s:2:"84";s:3:"ere";s:2:"85";s:3:"ium";s:2:"86";s:3:" ex";s:2:"87";s:3:"rat";s:2:"88";s:3:"ta ";s:2:"89";s:3:"con";s:2:"90";s:3:"cti";s:2:"91";s:3:"oni";s:2:"92";s:3:"ra ";s:2:"93";s:3:"s i";s:2:"94";s:3:" cu";s:2:"95";s:3:" sa";s:2:"96";s:3:"eni";s:2:"97";s:3:"nis";s:2:"98";s:3:"nte";s:2:"99";s:3:"eri";s:3:"100";s:3:"omi";s:3:"101";s:3:"re ";s:3:"102";s:3:"s a";s:3:"103";s:3:"min";s:3:"104";s:3:"os ";s:3:"105";s:3:"ti ";s:3:"106";s:3:"uer";s:3:"107";s:3:" ma";s:3:"108";s:3:" ue";s:3:"109";s:3:"m s";s:3:"110";s:3:"nem";s:3:"111";s:3:"t m";s:3:"112";s:3:" mo";s:3:"113";s:3:" po";s:3:"114";s:3:" ui";s:3:"115";s:3:"gen";s:3:"116";s:3:"ict";s:3:"117";s:3:"m i";s:3:"118";s:3:"ris";s:3:"119";s:3:"s s";s:3:"120";s:3:"t a";s:3:"121";s:3:"uae";s:3:"122";s:3:" do";s:3:"123";s:3:"m a";s:3:"124";s:3:"t c";s:3:"125";s:3:" ge";s:3:"126";s:3:"as ";s:3:"127";s:3:"e i";s:3:"128";s:3:"e p";s:3:"129";s:3:"ne ";s:3:"130";s:3:" ca";s:3:"131";s:3:"ine";s:3:"132";s:3:"quo";s:3:"133";s:3:"s p";s:3:"134";s:3:" al";s:3:"135";s:3:"e e";s:3:"136";s:3:"ntu";s:3:"137";s:3:"ro ";s:3:"138";s:3:"tri";s:3:"139";s:3:"tus";s:3:"140";s:3:"uit";s:3:"141";s:3:"atu";s:3:"142";s:3:"ini";s:3:"143";s:3:"iqu";s:3:"144";s:3:"m p";s:3:"145";s:3:"ost";s:3:"146";s:3:"res";s:3:"147";s:3:"ura";s:3:"148";s:3:" ac";s:3:"149";s:3:" fu";s:3:"150";s:3:"a e";s:3:"151";s:3:"ant";s:3:"152";s:3:"nes";s:3:"153";s:3:"nim";s:3:"154";s:3:"sun";s:3:"155";s:3:"tra";s:3:"156";s:3:"e a";s:3:"157";s:3:"s d";s:3:"158";s:3:" pa";s:3:"159";s:3:" uo";s:3:"160";s:3:"ecu";s:3:"161";s:3:" om";s:3:"162";s:3:" tu";s:3:"163";s:3:"ad ";s:3:"164";s:3:"cut";s:3:"165";s:3:"omn";s:3:"166";s:3:"s q";s:3:"167";s:3:" ei";s:3:"168";s:3:"ex ";s:3:"169";s:3:"icu";s:3:"170";s:3:"tor";s:3:"171";s:3:"uid";s:3:"172";s:3:" ip";s:3:"173";s:3:" me";s:3:"174";s:3:"e s";s:3:"175";s:3:"era";s:3:"176";s:3:"eru";s:3:"177";s:3:"iam";s:3:"178";s:3:"ide";s:3:"179";s:3:"ips";s:3:"180";s:3:" iu";s:3:"181";s:3:"a s";s:3:"182";s:3:"do ";s:3:"183";s:3:"e d";s:3:"184";s:3:"eiu";s:3:"185";s:3:"ica";s:3:"186";s:3:"im ";s:3:"187";s:3:"m c";s:3:"188";s:3:"m u";s:3:"189";s:3:"tiu";s:3:"190";s:3:" ho";s:3:"191";s:3:"cat";s:3:"192";s:3:"ist";s:3:"193";s:3:"nat";s:3:"194";s:3:"on ";s:3:"195";s:3:"pti";s:3:"196";s:3:"reg";s:3:"197";s:3:"rit";s:3:"198";s:3:"s t";s:3:"199";s:3:"sic";s:3:"200";s:3:"spe";s:3:"201";s:3:" en";s:3:"202";s:3:" sp";s:3:"203";s:3:"dis";s:3:"204";s:3:"eli";s:3:"205";s:3:"liq";s:3:"206";s:3:"lis";s:3:"207";s:3:"men";s:3:"208";s:3:"mus";s:3:"209";s:3:"num";s:3:"210";s:3:"pos";s:3:"211";s:3:"sio";s:3:"212";s:3:" an";s:3:"213";s:3:" gr";s:3:"214";s:3:"abi";s:3:"215";s:3:"acc";s:3:"216";s:3:"ect";s:3:"217";s:3:"ri ";s:3:"218";s:3:"uan";s:3:"219";s:3:" le";s:3:"220";s:3:"ecc";s:3:"221";s:3:"ete";s:3:"222";s:3:"gra";s:3:"223";s:3:"non";s:3:"224";s:3:"se ";s:3:"225";s:3:"uen";s:3:"226";s:3:"uis";s:3:"227";s:3:" fa";s:3:"228";s:3:" tr";s:3:"229";s:3:"ate";s:3:"230";s:3:"e c";s:3:"231";s:3:"fil";s:3:"232";s:3:"na ";s:3:"233";s:3:"ni ";s:3:"234";s:3:"pul";s:3:"235";s:3:"s f";s:3:"236";s:3:"ui ";s:3:"237";s:3:"at ";s:3:"238";s:3:"cce";s:3:"239";s:3:"dam";s:3:"240";s:3:"i e";s:3:"241";s:3:"ina";s:3:"242";s:3:"leg";s:3:"243";s:3:"nos";s:3:"244";s:3:"ori";s:3:"245";s:3:"pec";s:3:"246";s:3:"rop";s:3:"247";s:3:"sta";s:3:"248";s:3:"uia";s:3:"249";s:3:"ene";s:3:"250";s:3:"iue";s:3:"251";s:3:"iui";s:3:"252";s:3:"siu";s:3:"253";s:3:"t t";s:3:"254";s:3:"t u";s:3:"255";s:3:"tib";s:3:"256";s:3:"tit";s:3:"257";s:3:" da";s:3:"258";s:3:" ne";s:3:"259";s:3:"a d";s:3:"260";s:3:"and";s:3:"261";s:3:"ege";s:3:"262";s:3:"equ";s:3:"263";s:3:"hom";s:3:"264";s:3:"imu";s:3:"265";s:3:"lor";s:3:"266";s:3:"m m";s:3:"267";s:3:"mni";s:3:"268";s:3:"ndo";s:3:"269";s:3:"ner";s:3:"270";s:3:"o e";s:3:"271";s:3:"r e";s:3:"272";s:3:"sit";s:3:"273";s:3:"tum";s:3:"274";s:3:"utu";s:3:"275";s:3:"a p";s:3:"276";s:3:"bis";s:3:"277";s:3:"bit";s:3:"278";s:3:"cer";s:3:"279";s:3:"cta";s:3:"280";s:3:"dom";s:3:"281";s:3:"fut";s:3:"282";s:3:"i s";s:3:"283";s:3:"ign";s:3:"284";s:3:"int";s:3:"285";s:3:"mod";s:3:"286";s:3:"ndu";s:3:"287";s:3:"nit";s:3:"288";s:3:"rib";s:3:"289";s:3:"rti";s:3:"290";s:3:"tas";s:3:"291";s:3:"und";s:3:"292";s:3:" ab";s:3:"293";s:3:"err";s:3:"294";s:3:"ers";s:3:"295";s:3:"ite";s:3:"296";s:3:"iti";s:3:"297";s:3:"m t";s:3:"298";s:3:"o p";s:3:"299";}s:7:"latvian";a:300:{s:3:"as ";s:1:"0";s:3:" la";s:1:"1";s:3:" pa";s:1:"2";s:3:" ne";s:1:"3";s:3:"es ";s:1:"4";s:3:" un";s:1:"5";s:3:"un ";s:1:"6";s:3:" ka";s:1:"7";s:3:" va";s:1:"8";s:3:"ar ";s:1:"9";s:3:"s p";s:2:"10";s:3:" ar";s:2:"11";s:3:" vi";s:2:"12";s:3:"is ";s:2:"13";s:3:"ai ";s:2:"14";s:3:" no";s:2:"15";s:3:"ja ";s:2:"16";s:3:"ija";s:2:"17";s:3:"iem";s:2:"18";s:3:"em ";s:2:"19";s:3:"tu ";s:2:"20";s:3:"tie";s:2:"21";s:3:"vie";s:2:"22";s:3:"lat";s:2:"23";s:3:"aks";s:2:"24";s:3:"ien";s:2:"25";s:3:"kst";s:2:"26";s:3:"ies";s:2:"27";s:3:"s a";s:2:"28";s:3:"rak";s:2:"29";s:3:"atv";s:2:"30";s:3:"tvi";s:2:"31";s:3:" ja";s:2:"32";s:3:" pi";s:2:"33";s:3:"ka ";s:2:"34";s:3:" ir";s:2:"35";s:3:"ir ";s:2:"36";s:3:"ta ";s:2:"37";s:3:" sa";s:2:"38";s:3:"ts ";s:2:"39";s:4:" kā";s:2:"40";s:4:"ās ";s:2:"41";s:3:" ti";s:2:"42";s:3:"ot ";s:2:"43";s:3:"s n";s:2:"44";s:3:" ie";s:2:"45";s:3:" ta";s:2:"46";s:4:"arī";s:2:"47";s:3:"par";s:2:"48";s:3:"pie";s:2:"49";s:3:" pr";s:2:"50";s:4:"kā ";s:2:"51";s:3:" at";s:2:"52";s:3:" ra";s:2:"53";s:3:"am ";s:2:"54";s:4:"inā";s:2:"55";s:4:"tā ";s:2:"56";s:3:" iz";s:2:"57";s:3:"jas";s:2:"58";s:3:"lai";s:2:"59";s:3:" na";s:2:"60";s:3:"aut";s:2:"61";s:4:"ieš";s:2:"62";s:3:"s s";s:2:"63";s:3:" ap";s:2:"64";s:3:" ko";s:2:"65";s:3:" st";s:2:"66";s:3:"iek";s:2:"67";s:3:"iet";s:2:"68";s:3:"jau";s:2:"69";s:3:"us ";s:2:"70";s:4:"rī ";s:2:"71";s:3:"tik";s:2:"72";s:4:"ība";s:2:"73";s:3:"na ";s:2:"74";s:3:" ga";s:2:"75";s:3:"cij";s:2:"76";s:3:"s i";s:2:"77";s:3:" uz";s:2:"78";s:3:"jum";s:2:"79";s:3:"s v";s:2:"80";s:3:"ms ";s:2:"81";s:3:"var";s:2:"82";s:3:" ku";s:2:"83";s:3:" ma";s:2:"84";s:4:"jā ";s:2:"85";s:3:"sta";s:2:"86";s:3:"s u";s:2:"87";s:4:" tā";s:2:"88";s:3:"die";s:2:"89";s:3:"kai";s:2:"90";s:3:"kas";s:2:"91";s:3:"ska";s:2:"92";s:3:" ci";s:2:"93";s:3:" da";s:2:"94";s:3:"kur";s:2:"95";s:3:"lie";s:2:"96";s:3:"tas";s:2:"97";s:3:"a p";s:2:"98";s:3:"est";s:2:"99";s:4:"stā";s:3:"100";s:4:"šan";s:3:"101";s:3:"nes";s:3:"102";s:3:"nie";s:3:"103";s:3:"s d";s:3:"104";s:3:"s m";s:3:"105";s:3:"val";s:3:"106";s:3:" di";s:3:"107";s:3:" es";s:3:"108";s:3:" re";s:3:"109";s:3:"no ";s:3:"110";s:3:"to ";s:3:"111";s:3:"umu";s:3:"112";s:3:"vai";s:3:"113";s:4:"ši ";s:3:"114";s:4:" vē";s:3:"115";s:3:"kum";s:3:"116";s:3:"nu ";s:3:"117";s:3:"rie";s:3:"118";s:3:"s t";s:3:"119";s:4:"ām ";s:3:"120";s:3:"ad ";s:3:"121";s:3:"et ";s:3:"122";s:3:"mu ";s:3:"123";s:3:"s l";s:3:"124";s:3:" be";s:3:"125";s:3:"aud";s:3:"126";s:3:"tur";s:3:"127";s:3:"vij";s:3:"128";s:4:"viņ";s:3:"129";s:4:"āju";s:3:"130";s:3:"bas";s:3:"131";s:3:"gad";s:3:"132";s:3:"i n";s:3:"133";s:3:"ika";s:3:"134";s:3:"os ";s:3:"135";s:3:"a v";s:3:"136";s:3:"not";s:3:"137";s:3:"oti";s:3:"138";s:3:"sts";s:3:"139";s:3:"aik";s:3:"140";s:3:"u a";s:3:"141";s:4:"ā a";s:3:"142";s:4:"āk ";s:3:"143";s:3:" to";s:3:"144";s:3:"ied";s:3:"145";s:3:"stu";s:3:"146";s:3:"ti ";s:3:"147";s:3:"u p";s:3:"148";s:4:"vēl";s:3:"149";s:4:"āci";s:3:"150";s:4:" šo";s:3:"151";s:3:"gi ";s:3:"152";s:3:"ko ";s:3:"153";s:3:"pro";s:3:"154";s:3:"s r";s:3:"155";s:4:"tāj";s:3:"156";s:3:"u s";s:3:"157";s:3:"u v";s:3:"158";s:3:"vis";s:3:"159";s:3:"aun";s:3:"160";s:3:"ks ";s:3:"161";s:3:"str";s:3:"162";s:3:"zin";s:3:"163";s:3:"a a";s:3:"164";s:4:"adī";s:3:"165";s:3:"da ";s:3:"166";s:3:"dar";s:3:"167";s:3:"ena";s:3:"168";s:3:"ici";s:3:"169";s:3:"kra";s:3:"170";s:3:"nas";s:3:"171";s:4:"stī";s:3:"172";s:4:"šu ";s:3:"173";s:4:" mē";s:3:"174";s:3:"a n";s:3:"175";s:3:"eci";s:3:"176";s:3:"i s";s:3:"177";s:3:"ie ";s:3:"178";s:4:"iņa";s:3:"179";s:3:"ju ";s:3:"180";s:3:"las";s:3:"181";s:3:"r t";s:3:"182";s:3:"ums";s:3:"183";s:4:"šie";s:3:"184";s:3:"bu ";s:3:"185";s:3:"cit";s:3:"186";s:3:"i a";s:3:"187";s:3:"ina";s:3:"188";s:3:"ma ";s:3:"189";s:3:"pus";s:3:"190";s:3:"ra ";s:3:"191";s:3:" au";s:3:"192";s:3:" se";s:3:"193";s:3:" sl";s:3:"194";s:3:"a s";s:3:"195";s:3:"ais";s:3:"196";s:4:"eši";s:3:"197";s:3:"iec";s:3:"198";s:3:"iku";s:3:"199";s:4:"pār";s:3:"200";s:3:"s b";s:3:"201";s:3:"s k";s:3:"202";s:3:"sot";s:3:"203";s:5:"ādā";s:3:"204";s:3:" in";s:3:"205";s:3:" li";s:3:"206";s:3:" tr";s:3:"207";s:3:"ana";s:3:"208";s:3:"eso";s:3:"209";s:3:"ikr";s:3:"210";s:3:"man";s:3:"211";s:3:"ne ";s:3:"212";s:3:"u k";s:3:"213";s:3:" tu";s:3:"214";s:3:"an ";s:3:"215";s:3:"av ";s:3:"216";s:3:"bet";s:3:"217";s:4:"būt";s:3:"218";s:3:"im ";s:3:"219";s:3:"isk";s:3:"220";s:4:"līd";s:3:"221";s:3:"nav";s:3:"222";s:3:"ras";s:3:"223";s:3:"ri ";s:3:"224";s:3:"s g";s:3:"225";s:3:"sti";s:3:"226";s:4:"īdz";s:3:"227";s:3:" ai";s:3:"228";s:3:"arb";s:3:"229";s:3:"cin";s:3:"230";s:3:"das";s:3:"231";s:3:"ent";s:3:"232";s:3:"gal";s:3:"233";s:3:"i p";s:3:"234";s:3:"lik";s:3:"235";s:4:"mā ";s:3:"236";s:3:"nek";s:3:"237";s:3:"pat";s:3:"238";s:4:"rēt";s:3:"239";s:3:"si ";s:3:"240";s:3:"tra";s:3:"241";s:4:"uši";s:3:"242";s:3:"vei";s:3:"243";s:3:" br";s:3:"244";s:3:" pu";s:3:"245";s:3:" sk";s:3:"246";s:3:"als";s:3:"247";s:3:"ama";s:3:"248";s:3:"edz";s:3:"249";s:3:"eka";s:3:"250";s:4:"ešu";s:3:"251";s:3:"ieg";s:3:"252";s:3:"jis";s:3:"253";s:3:"kam";s:3:"254";s:3:"lst";s:3:"255";s:4:"nāk";s:3:"256";s:3:"oli";s:3:"257";s:3:"pre";s:3:"258";s:4:"pēc";s:3:"259";s:3:"rot";s:3:"260";s:4:"tās";s:3:"261";s:3:"usi";s:3:"262";s:4:"ēl ";s:3:"263";s:4:"ēs ";s:3:"264";s:3:" bi";s:3:"265";s:3:" de";s:3:"266";s:3:" me";s:3:"267";s:4:" pā";s:3:"268";s:3:"a i";s:3:"269";s:3:"aid";s:3:"270";s:4:"ajā";s:3:"271";s:3:"ikt";s:3:"272";s:3:"kat";s:3:"273";s:3:"lic";s:3:"274";s:3:"lod";s:3:"275";s:3:"mi ";s:3:"276";s:3:"ni ";s:3:"277";s:3:"pri";s:3:"278";s:4:"rād";s:3:"279";s:4:"rīg";s:3:"280";s:3:"sim";s:3:"281";s:4:"trā";s:3:"282";s:3:"u l";s:3:"283";s:3:"uto";s:3:"284";s:3:"uz ";s:3:"285";s:4:"ēc ";s:3:"286";s:5:"ītā";s:3:"287";s:3:" ce";s:3:"288";s:4:" jā";s:3:"289";s:3:" sv";s:3:"290";s:3:"a t";s:3:"291";s:3:"aga";s:3:"292";s:3:"aiz";s:3:"293";s:3:"atu";s:3:"294";s:3:"ba ";s:3:"295";s:3:"cie";s:3:"296";s:3:"du ";s:3:"297";s:3:"dzi";s:3:"298";s:4:"dzī";s:3:"299";}s:10:"lithuanian";a:300:{s:3:"as ";s:1:"0";s:3:" pa";s:1:"1";s:3:" ka";s:1:"2";s:3:"ai ";s:1:"3";s:3:"us ";s:1:"4";s:3:"os ";s:1:"5";s:3:"is ";s:1:"6";s:3:" ne";s:1:"7";s:3:" ir";s:1:"8";s:3:"ir ";s:1:"9";s:3:"ti ";s:2:"10";s:3:" pr";s:2:"11";s:3:"aus";s:2:"12";s:3:"ini";s:2:"13";s:3:"s p";s:2:"14";s:3:"pas";s:2:"15";s:4:"ių ";s:2:"16";s:3:" ta";s:2:"17";s:3:" vi";s:2:"18";s:3:"iau";s:2:"19";s:3:" ko";s:2:"20";s:3:" su";s:2:"21";s:3:"kai";s:2:"22";s:3:"o p";s:2:"23";s:3:"usi";s:2:"24";s:3:" sa";s:2:"25";s:3:"vo ";s:2:"26";s:3:"tai";s:2:"27";s:3:"ali";s:2:"28";s:4:"tų ";s:2:"29";s:3:"io ";s:2:"30";s:3:"jo ";s:2:"31";s:3:"s k";s:2:"32";s:3:"sta";s:2:"33";s:3:"iai";s:2:"34";s:3:" bu";s:2:"35";s:3:" nu";s:2:"36";s:3:"ius";s:2:"37";s:3:"mo ";s:2:"38";s:3:" po";s:2:"39";s:3:"ien";s:2:"40";s:3:"s s";s:2:"41";s:3:"tas";s:2:"42";s:3:" me";s:2:"43";s:3:"uvo";s:2:"44";s:3:"kad";s:2:"45";s:4:" iš";s:2:"46";s:3:" la";s:2:"47";s:3:"to ";s:2:"48";s:3:"ais";s:2:"49";s:3:"ie ";s:2:"50";s:3:"kur";s:2:"51";s:3:"uri";s:2:"52";s:3:" ku";s:2:"53";s:3:"ijo";s:2:"54";s:4:"čia";s:2:"55";s:3:"au ";s:2:"56";s:3:"met";s:2:"57";s:3:"je ";s:2:"58";s:3:" va";s:2:"59";s:3:"ad ";s:2:"60";s:3:" ap";s:2:"61";s:3:"and";s:2:"62";s:3:" gr";s:2:"63";s:3:" ti";s:2:"64";s:3:"kal";s:2:"65";s:3:"asi";s:2:"66";s:3:"i p";s:2:"67";s:4:"iči";s:2:"68";s:3:"s i";s:2:"69";s:3:"s v";s:2:"70";s:3:"ink";s:2:"71";s:3:"o n";s:2:"72";s:4:"ės ";s:2:"73";s:3:"buv";s:2:"74";s:3:"s a";s:2:"75";s:3:" ga";s:2:"76";s:3:"aip";s:2:"77";s:3:"avi";s:2:"78";s:3:"mas";s:2:"79";s:3:"pri";s:2:"80";s:3:"tik";s:2:"81";s:3:" re";s:2:"82";s:3:"etu";s:2:"83";s:3:"jos";s:2:"84";s:3:" da";s:2:"85";s:3:"ent";s:2:"86";s:3:"oli";s:2:"87";s:3:"par";s:2:"88";s:3:"ant";s:2:"89";s:3:"ara";s:2:"90";s:3:"tar";s:2:"91";s:3:"ama";s:2:"92";s:3:"gal";s:2:"93";s:3:"imo";s:2:"94";s:4:"išk";s:2:"95";s:3:"o s";s:2:"96";s:3:" at";s:2:"97";s:3:" be";s:2:"98";s:4:" į ";s:2:"99";s:3:"min";s:3:"100";s:3:"tin";s:3:"101";s:3:" tu";s:3:"102";s:3:"s n";s:3:"103";s:3:" jo";s:3:"104";s:3:"dar";s:3:"105";s:3:"ip ";s:3:"106";s:3:"rei";s:3:"107";s:3:" te";s:3:"108";s:4:"dži";s:3:"109";s:3:"kas";s:3:"110";s:3:"nin";s:3:"111";s:3:"tei";s:3:"112";s:3:"vie";s:3:"113";s:3:" li";s:3:"114";s:3:" se";s:3:"115";s:3:"cij";s:3:"116";s:3:"gar";s:3:"117";s:3:"lai";s:3:"118";s:3:"art";s:3:"119";s:3:"lau";s:3:"120";s:3:"ras";s:3:"121";s:3:"no ";s:3:"122";s:3:"o k";s:3:"123";s:4:"tą ";s:3:"124";s:3:" ar";s:3:"125";s:4:"ėjo";s:3:"126";s:4:"vič";s:3:"127";s:3:"iga";s:3:"128";s:3:"pra";s:3:"129";s:3:"vis";s:3:"130";s:3:" na";s:3:"131";s:3:"men";s:3:"132";s:3:"oki";s:3:"133";s:4:"raš";s:3:"134";s:3:"s t";s:3:"135";s:3:"iet";s:3:"136";s:3:"ika";s:3:"137";s:3:"int";s:3:"138";s:3:"kom";s:3:"139";s:3:"tam";s:3:"140";s:3:"aug";s:3:"141";s:3:"avo";s:3:"142";s:3:"rie";s:3:"143";s:3:"s b";s:3:"144";s:3:" st";s:3:"145";s:3:"eim";s:3:"146";s:3:"ko ";s:3:"147";s:3:"nus";s:3:"148";s:3:"pol";s:3:"149";s:3:"ria";s:3:"150";s:3:"sau";s:3:"151";s:3:"api";s:3:"152";s:3:"me ";s:3:"153";s:3:"ne ";s:3:"154";s:3:"sik";s:3:"155";s:4:" ši";s:3:"156";s:3:"i n";s:3:"157";s:3:"ia ";s:3:"158";s:3:"ici";s:3:"159";s:3:"oja";s:3:"160";s:3:"sak";s:3:"161";s:3:"sti";s:3:"162";s:3:"ui ";s:3:"163";s:3:"ame";s:3:"164";s:3:"lie";s:3:"165";s:3:"o t";s:3:"166";s:3:"pie";s:3:"167";s:4:"čiu";s:3:"168";s:3:" di";s:3:"169";s:3:" pe";s:3:"170";s:3:"gri";s:3:"171";s:3:"ios";s:3:"172";s:3:"lia";s:3:"173";s:3:"lin";s:3:"174";s:3:"s d";s:3:"175";s:3:"s g";s:3:"176";s:3:"ta ";s:3:"177";s:3:"uot";s:3:"178";s:3:" ja";s:3:"179";s:4:" už";s:3:"180";s:3:"aut";s:3:"181";s:3:"i s";s:3:"182";s:3:"ino";s:3:"183";s:4:"mą ";s:3:"184";s:3:"oje";s:3:"185";s:3:"rav";s:3:"186";s:4:"dėl";s:3:"187";s:3:"nti";s:3:"188";s:3:"o a";s:3:"189";s:3:"toj";s:3:"190";s:4:"ėl ";s:3:"191";s:3:" to";s:3:"192";s:3:" vy";s:3:"193";s:3:"ar ";s:3:"194";s:3:"ina";s:3:"195";s:3:"lic";s:3:"196";s:3:"o v";s:3:"197";s:3:"sei";s:3:"198";s:3:"su ";s:3:"199";s:3:" mi";s:3:"200";s:3:" pi";s:3:"201";s:3:"din";s:3:"202";s:4:"iš ";s:3:"203";s:3:"lan";s:3:"204";s:3:"si ";s:3:"205";s:3:"tus";s:3:"206";s:3:" ba";s:3:"207";s:3:"asa";s:3:"208";s:3:"ata";s:3:"209";s:3:"kla";s:3:"210";s:3:"omi";s:3:"211";s:3:"tat";s:3:"212";s:3:" an";s:3:"213";s:3:" ji";s:3:"214";s:3:"als";s:3:"215";s:3:"ena";s:3:"216";s:4:"jų ";s:3:"217";s:3:"nuo";s:3:"218";s:3:"per";s:3:"219";s:3:"rig";s:3:"220";s:3:"s m";s:3:"221";s:3:"val";s:3:"222";s:3:"yta";s:3:"223";s:4:"čio";s:3:"224";s:3:" ra";s:3:"225";s:3:"i k";s:3:"226";s:3:"lik";s:3:"227";s:3:"net";s:3:"228";s:4:"nė ";s:3:"229";s:3:"tis";s:3:"230";s:3:"tuo";s:3:"231";s:3:"yti";s:3:"232";s:4:"ęs ";s:3:"233";s:4:"ų s";s:3:"234";s:3:"ada";s:3:"235";s:3:"ari";s:3:"236";s:3:"do ";s:3:"237";s:3:"eik";s:3:"238";s:3:"eis";s:3:"239";s:3:"ist";s:3:"240";s:3:"lst";s:3:"241";s:3:"ma ";s:3:"242";s:3:"nes";s:3:"243";s:3:"sav";s:3:"244";s:3:"sio";s:3:"245";s:3:"tau";s:3:"246";s:3:" ki";s:3:"247";s:3:"aik";s:3:"248";s:3:"aud";s:3:"249";s:3:"ies";s:3:"250";s:3:"ori";s:3:"251";s:3:"s r";s:3:"252";s:3:"ska";s:3:"253";s:3:" ge";s:3:"254";s:3:"ast";s:3:"255";s:3:"eig";s:3:"256";s:3:"et ";s:3:"257";s:3:"iam";s:3:"258";s:3:"isa";s:3:"259";s:3:"mis";s:3:"260";s:3:"nam";s:3:"261";s:3:"ome";s:3:"262";s:4:"žia";s:3:"263";s:3:"aba";s:3:"264";s:3:"aul";s:3:"265";s:3:"ikr";s:3:"266";s:4:"ką ";s:3:"267";s:3:"nta";s:3:"268";s:3:"ra ";s:3:"269";s:3:"tur";s:3:"270";s:3:" ma";s:3:"271";s:3:"die";s:3:"272";s:3:"ei ";s:3:"273";s:3:"i t";s:3:"274";s:3:"nas";s:3:"275";s:3:"rin";s:3:"276";s:3:"sto";s:3:"277";s:3:"tie";s:3:"278";s:3:"tuv";s:3:"279";s:3:"vos";s:3:"280";s:4:"ų p";s:3:"281";s:4:" dė";s:3:"282";s:3:"are";s:3:"283";s:3:"ats";s:3:"284";s:4:"enė";s:3:"285";s:3:"ili";s:3:"286";s:3:"ima";s:3:"287";s:3:"kar";s:3:"288";s:3:"ms ";s:3:"289";s:3:"nia";s:3:"290";s:3:"r p";s:3:"291";s:3:"rod";s:3:"292";s:3:"s l";s:3:"293";s:3:" o ";s:3:"294";s:3:"e p";s:3:"295";s:3:"es ";s:3:"296";s:3:"ide";s:3:"297";s:3:"ik ";s:3:"298";s:3:"ja ";s:3:"299";}s:10:"macedonian";a:300:{s:5:"на ";s:1:"0";s:5:" на";s:1:"1";s:5:"та ";s:1:"2";s:6:"ата";s:1:"3";s:6:"ија";s:1:"4";s:5:" пр";s:1:"5";s:5:"то ";s:1:"6";s:5:"ја ";s:1:"7";s:5:" за";s:1:"8";s:5:"а н";s:1:"9";s:4:" и ";s:2:"10";s:5:"а с";s:2:"11";s:5:"те ";s:2:"12";s:6:"ите";s:2:"13";s:5:" ко";s:2:"14";s:5:"от ";s:2:"15";s:5:" де";s:2:"16";s:5:" по";s:2:"17";s:5:"а д";s:2:"18";s:5:"во ";s:2:"19";s:5:"за ";s:2:"20";s:5:" во";s:2:"21";s:5:" од";s:2:"22";s:5:" се";s:2:"23";s:5:" не";s:2:"24";s:5:"се ";s:2:"25";s:5:" до";s:2:"26";s:5:"а в";s:2:"27";s:5:"ка ";s:2:"28";s:6:"ање";s:2:"29";s:5:"а п";s:2:"30";s:5:"о п";s:2:"31";s:6:"ува";s:2:"32";s:6:"циј";s:2:"33";s:5:"а о";s:2:"34";s:6:"ици";s:2:"35";s:6:"ето";s:2:"36";s:5:"о н";s:2:"37";s:6:"ани";s:2:"38";s:5:"ни ";s:2:"39";s:5:" вл";s:2:"40";s:6:"дек";s:2:"41";s:6:"ека";s:2:"42";s:6:"њет";s:2:"43";s:5:"ќе ";s:2:"44";s:4:" е ";s:2:"45";s:5:"а з";s:2:"46";s:5:"а и";s:2:"47";s:5:"ат ";s:2:"48";s:6:"вла";s:2:"49";s:5:"го ";s:2:"50";s:5:"е н";s:2:"51";s:5:"од ";s:2:"52";s:6:"пре";s:2:"53";s:5:" го";s:2:"54";s:5:" да";s:2:"55";s:5:" ма";s:2:"56";s:5:" ре";s:2:"57";s:5:" ќе";s:2:"58";s:6:"али";s:2:"59";s:5:"и д";s:2:"60";s:5:"и н";s:2:"61";s:6:"иот";s:2:"62";s:6:"нат";s:2:"63";s:6:"ово";s:2:"64";s:5:" па";s:2:"65";s:5:" ра";s:2:"66";s:5:" со";s:2:"67";s:6:"ове";s:2:"68";s:6:"пра";s:2:"69";s:6:"што";s:2:"70";s:5:"ње ";s:2:"71";s:5:"а е";s:2:"72";s:5:"да ";s:2:"73";s:6:"дат";s:2:"74";s:6:"дон";s:2:"75";s:5:"е в";s:2:"76";s:5:"е д";s:2:"77";s:5:"е з";s:2:"78";s:5:"е с";s:2:"79";s:6:"кон";s:2:"80";s:6:"нит";s:2:"81";s:5:"но ";s:2:"82";s:6:"они";s:2:"83";s:6:"ото";s:2:"84";s:6:"пар";s:2:"85";s:6:"при";s:2:"86";s:6:"ста";s:2:"87";s:5:"т н";s:2:"88";s:5:" шт";s:2:"89";s:5:"а к";s:2:"90";s:6:"аци";s:2:"91";s:5:"ва ";s:2:"92";s:6:"вањ";s:2:"93";s:5:"е п";s:2:"94";s:6:"ени";s:2:"95";s:5:"ла ";s:2:"96";s:6:"лад";s:2:"97";s:6:"мак";s:2:"98";s:6:"нес";s:2:"99";s:6:"нос";s:3:"100";s:6:"про";s:3:"101";s:6:"рен";s:3:"102";s:6:"јат";s:3:"103";s:5:" ин";s:3:"104";s:5:" ме";s:3:"105";s:5:" то";s:3:"106";s:5:"а г";s:3:"107";s:5:"а м";s:3:"108";s:5:"а р";s:3:"109";s:6:"аке";s:3:"110";s:6:"ако";s:3:"111";s:6:"вор";s:3:"112";s:6:"гов";s:3:"113";s:6:"едо";s:3:"114";s:6:"ена";s:3:"115";s:5:"и и";s:3:"116";s:6:"ира";s:3:"117";s:6:"кед";s:3:"118";s:5:"не ";s:3:"119";s:6:"ниц";s:3:"120";s:6:"ниј";s:3:"121";s:6:"ост";s:3:"122";s:5:"ра ";s:3:"123";s:6:"рат";s:3:"124";s:6:"ред";s:3:"125";s:6:"ска";s:3:"126";s:6:"тен";s:3:"127";s:5:" ка";s:3:"128";s:5:" сп";s:3:"129";s:5:" ја";s:3:"130";s:5:"а т";s:3:"131";s:6:"аде";s:3:"132";s:6:"арт";s:3:"133";s:5:"е г";s:3:"134";s:5:"е и";s:3:"135";s:6:"кат";s:3:"136";s:6:"лас";s:3:"137";s:6:"нио";s:3:"138";s:5:"о с";s:3:"139";s:5:"ри ";s:3:"140";s:5:" ба";s:3:"141";s:5:" би";s:3:"142";s:6:"ава";s:3:"143";s:6:"ате";s:3:"144";s:6:"вни";s:3:"145";s:5:"д н";s:3:"146";s:6:"ден";s:3:"147";s:6:"дов";s:3:"148";s:6:"држ";s:3:"149";s:6:"дув";s:3:"150";s:5:"е о";s:3:"151";s:5:"ен ";s:3:"152";s:6:"ере";s:3:"153";s:6:"ери";s:3:"154";s:5:"и п";s:3:"155";s:5:"и с";s:3:"156";s:6:"ина";s:3:"157";s:6:"кој";s:3:"158";s:6:"нци";s:3:"159";s:5:"о м";s:3:"160";s:5:"о о";s:3:"161";s:6:"одн";s:3:"162";s:6:"пор";s:3:"163";s:6:"ски";s:3:"164";s:6:"спо";s:3:"165";s:6:"ств";s:3:"166";s:6:"сти";s:3:"167";s:6:"тво";s:3:"168";s:5:"ти ";s:3:"169";s:5:" об";s:3:"170";s:5:" ов";s:3:"171";s:5:"а б";s:3:"172";s:6:"алн";s:3:"173";s:6:"ара";s:3:"174";s:6:"бар";s:3:"175";s:5:"е к";s:3:"176";s:5:"ед ";s:3:"177";s:6:"ент";s:3:"178";s:6:"еѓу";s:3:"179";s:5:"и о";s:3:"180";s:5:"ии ";s:3:"181";s:6:"меѓ";s:3:"182";s:5:"о д";s:3:"183";s:6:"оја";s:3:"184";s:6:"пот";s:3:"185";s:6:"раз";s:3:"186";s:6:"раш";s:3:"187";s:6:"спр";s:3:"188";s:6:"сто";s:3:"189";s:5:"т д";s:3:"190";s:5:"ци ";s:3:"191";s:5:" бе";s:3:"192";s:5:" гр";s:3:"193";s:5:" др";s:3:"194";s:5:" из";s:3:"195";s:5:" ст";s:3:"196";s:5:"аа ";s:3:"197";s:6:"бид";s:3:"198";s:6:"вед";s:3:"199";s:6:"гла";s:3:"200";s:6:"еко";s:3:"201";s:6:"енд";s:3:"202";s:6:"есе";s:3:"203";s:6:"етс";s:3:"204";s:6:"зац";s:3:"205";s:5:"и т";s:3:"206";s:6:"иза";s:3:"207";s:6:"инс";s:3:"208";s:6:"ист";s:3:"209";s:5:"ки ";s:3:"210";s:6:"ков";s:3:"211";s:6:"кол";s:3:"212";s:5:"ку ";s:3:"213";s:6:"лиц";s:3:"214";s:5:"о з";s:3:"215";s:5:"о и";s:3:"216";s:6:"ова";s:3:"217";s:6:"олк";s:3:"218";s:6:"оре";s:3:"219";s:6:"ори";s:3:"220";s:6:"под";s:3:"221";s:6:"рањ";s:3:"222";s:6:"реф";s:3:"223";s:6:"ржа";s:3:"224";s:6:"ров";s:3:"225";s:6:"рти";s:3:"226";s:5:"со ";s:3:"227";s:6:"тор";s:3:"228";s:6:"фер";s:3:"229";s:6:"цен";s:3:"230";s:6:"цит";s:3:"231";s:4:" а ";s:3:"232";s:5:" вр";s:3:"233";s:5:" гл";s:3:"234";s:5:" дп";s:3:"235";s:5:" мо";s:3:"236";s:5:" ни";s:3:"237";s:5:" но";s:3:"238";s:5:" оп";s:3:"239";s:5:" от";s:3:"240";s:5:"а ќ";s:3:"241";s:6:"або";s:3:"242";s:6:"ада";s:3:"243";s:6:"аса";s:3:"244";s:6:"аша";s:3:"245";s:5:"ба ";s:3:"246";s:6:"бот";s:3:"247";s:6:"ваа";s:3:"248";s:6:"ват";s:3:"249";s:6:"вот";s:3:"250";s:5:"ги ";s:3:"251";s:6:"гра";s:3:"252";s:5:"де ";s:3:"253";s:6:"дин";s:3:"254";s:6:"дум";s:3:"255";s:6:"евр";s:3:"256";s:6:"еду";s:3:"257";s:6:"ено";s:3:"258";s:6:"ера";s:3:"259";s:5:"ес ";s:3:"260";s:6:"ење";s:3:"261";s:5:"же ";s:3:"262";s:6:"зак";s:3:"263";s:5:"и в";s:3:"264";s:6:"ила";s:3:"265";s:6:"иту";s:3:"266";s:6:"коа";s:3:"267";s:6:"кои";s:3:"268";s:6:"лан";s:3:"269";s:6:"лку";s:3:"270";s:6:"лож";s:3:"271";s:6:"мот";s:3:"272";s:6:"нду";s:3:"273";s:6:"нст";s:3:"274";s:5:"о в";s:3:"275";s:5:"оа ";s:3:"276";s:6:"оал";s:3:"277";s:6:"обр";s:3:"278";s:5:"ов ";s:3:"279";s:6:"ови";s:3:"280";s:6:"овн";s:3:"281";s:5:"ои ";s:3:"282";s:5:"ор ";s:3:"283";s:6:"орм";s:3:"284";s:5:"ој ";s:3:"285";s:6:"рет";s:3:"286";s:6:"сед";s:3:"287";s:5:"ст ";s:3:"288";s:6:"тер";s:3:"289";s:6:"тиј";s:3:"290";s:6:"тоа";s:3:"291";s:6:"фор";s:3:"292";s:6:"ции";s:3:"293";s:5:"ѓу ";s:3:"294";s:5:" ал";s:3:"295";s:5:" ве";s:3:"296";s:5:" вм";s:3:"297";s:5:" ги";s:3:"298";s:5:" ду";s:3:"299";}s:9:"mongolian";a:300:{s:5:"ын ";s:1:"0";s:5:" ба";s:1:"1";s:5:"йн ";s:1:"2";s:6:"бай";s:1:"3";s:6:"ийн";s:1:"4";s:6:"уул";s:1:"5";s:5:" ул";s:1:"6";s:6:"улс";s:1:"7";s:5:"ан ";s:1:"8";s:5:" ха";s:1:"9";s:6:"ний";s:2:"10";s:5:"н х";s:2:"11";s:6:"гаа";s:2:"12";s:6:"сын";s:2:"13";s:5:"ий ";s:2:"14";s:6:"лсы";s:2:"15";s:5:" бо";s:2:"16";s:5:"й б";s:2:"17";s:5:"эн ";s:2:"18";s:5:"ах ";s:2:"19";s:6:"бол";s:2:"20";s:5:"ол ";s:2:"21";s:5:"н б";s:2:"22";s:6:"оло";s:2:"23";s:5:" хэ";s:2:"24";s:6:"онг";s:2:"25";s:6:"гол";s:2:"26";s:6:"гуу";s:2:"27";s:6:"нго";s:2:"28";s:5:"ыг ";s:2:"29";s:6:"жил";s:2:"30";s:5:" мо";s:2:"31";s:6:"лаг";s:2:"32";s:6:"лла";s:2:"33";s:6:"мон";s:2:"34";s:5:" тє";s:2:"35";s:5:" ху";s:2:"36";s:6:"айд";s:2:"37";s:5:"ны ";s:2:"38";s:5:"он ";s:2:"39";s:6:"сан";s:2:"40";s:6:"хий";s:2:"41";s:5:" аж";s:2:"42";s:5:" ор";s:2:"43";s:5:"л у";s:2:"44";s:5:"н т";s:2:"45";s:6:"улг";s:2:"46";s:6:"айг";s:2:"47";s:6:"длы";s:2:"48";s:5:"йг ";s:2:"49";s:5:" за";s:2:"50";s:6:"дэс";s:2:"51";s:5:"н а";s:2:"52";s:6:"ндэ";s:2:"53";s:6:"ула";s:2:"54";s:5:"ээ ";s:2:"55";s:6:"ага";s:2:"56";s:6:"ийг";s:2:"57";s:4:"vй ";s:2:"58";s:5:"аа ";s:2:"59";s:5:"й а";s:2:"60";s:6:"лын";s:2:"61";s:5:"н з";s:2:"62";s:5:" аю";s:2:"63";s:5:" зє";s:2:"64";s:6:"аар";s:2:"65";s:5:"ад ";s:2:"66";s:5:"ар ";s:2:"67";s:5:"гvй";s:2:"68";s:6:"зєв";s:2:"69";s:6:"ажи";s:2:"70";s:5:"ал ";s:2:"71";s:6:"аюу";s:2:"72";s:5:"г х";s:2:"73";s:5:"лгv";s:2:"74";s:5:"лж ";s:2:"75";s:6:"сни";s:2:"76";s:6:"эсн";s:2:"77";s:6:"юул";s:2:"78";s:6:"йдл";s:2:"79";s:6:"лыг";s:2:"80";s:6:"нхи";s:2:"81";s:6:"ууд";s:2:"82";s:6:"хам";s:2:"83";s:5:" нэ";s:2:"84";s:5:" са";s:2:"85";s:6:"гий";s:2:"86";s:6:"лах";s:2:"87";s:6:"лєл";s:2:"88";s:6:"рєн";s:2:"89";s:6:"єгч";s:2:"90";s:5:" та";s:2:"91";s:6:"илл";s:2:"92";s:6:"лий";s:2:"93";s:6:"лэх";s:2:"94";s:6:"рий";s:2:"95";s:5:"эх ";s:2:"96";s:5:" ер";s:2:"97";s:5:" эр";s:2:"98";s:6:"влє";s:2:"99";s:6:"ерє";s:3:"100";s:6:"ийл";s:3:"101";s:6:"лон";s:3:"102";s:6:"лєг";s:3:"103";s:6:"євл";s:3:"104";s:6:"єнх";s:3:"105";s:5:" хо";s:3:"106";s:6:"ари";s:3:"107";s:5:"их ";s:3:"108";s:6:"хан";s:3:"109";s:5:"эр ";s:3:"110";s:5:"єн ";s:3:"111";s:4:"vvл";s:3:"112";s:5:"ж б";s:3:"113";s:6:"тэй";s:3:"114";s:5:"х х";s:3:"115";s:6:"эрх";s:3:"116";s:4:" vн";s:3:"117";s:5:" нь";s:3:"118";s:5:"vнд";s:3:"119";s:6:"алт";s:3:"120";s:6:"йлє";s:3:"121";s:5:"нь ";s:3:"122";s:6:"тєр";s:3:"123";s:5:" га";s:3:"124";s:5:" су";s:3:"125";s:6:"аан";s:3:"126";s:6:"даа";s:3:"127";s:6:"илц";s:3:"128";s:6:"йгу";s:3:"129";s:5:"л а";s:3:"130";s:6:"лаа";s:3:"131";s:5:"н н";s:3:"132";s:6:"руу";s:3:"133";s:5:"эй ";s:3:"134";s:5:" то";s:3:"135";s:5:"н с";s:3:"136";s:6:"рил";s:3:"137";s:6:"єри";s:3:"138";s:6:"ааг";s:3:"139";s:5:"гч ";s:3:"140";s:6:"лээ";s:3:"141";s:5:"н о";s:3:"142";s:6:"рэг";s:3:"143";s:6:"суу";s:3:"144";s:6:"эрэ";s:3:"145";s:6:"їїл";s:3:"146";s:4:" yн";s:3:"147";s:5:" бу";s:3:"148";s:5:" дэ";s:3:"149";s:5:" ол";s:3:"150";s:5:" ту";s:3:"151";s:5:" ши";s:3:"152";s:5:"yнд";s:3:"153";s:6:"аши";s:3:"154";s:5:"г т";s:3:"155";s:5:"иг ";s:3:"156";s:5:"йл ";s:3:"157";s:6:"хар";s:3:"158";s:6:"шин";s:3:"159";s:5:"эг ";s:3:"160";s:5:"єр ";s:3:"161";s:5:" их";s:3:"162";s:5:" хє";s:3:"163";s:5:" хї";s:3:"164";s:5:"ам ";s:3:"165";s:6:"анг";s:3:"166";s:5:"ин ";s:3:"167";s:6:"йга";s:3:"168";s:6:"лса";s:3:"169";s:4:"н v";s:3:"170";s:5:"н е";s:3:"171";s:6:"нал";s:3:"172";s:5:"нд ";s:3:"173";s:6:"хуу";s:3:"174";s:6:"цаа";s:3:"175";s:5:"эд ";s:3:"176";s:6:"ээр";s:3:"177";s:5:"єл ";s:3:"178";s:5:"vйл";s:3:"179";s:6:"ада";s:3:"180";s:6:"айн";s:3:"181";s:6:"ала";s:3:"182";s:6:"амт";s:3:"183";s:6:"гах";s:3:"184";s:5:"д х";s:3:"185";s:6:"дал";s:3:"186";s:6:"зар";s:3:"187";s:5:"л б";s:3:"188";s:6:"лан";s:3:"189";s:5:"н д";s:3:"190";s:6:"сэн";s:3:"191";s:6:"улл";s:3:"192";s:5:"х б";s:3:"193";s:6:"хэр";s:3:"194";s:4:" бv";s:3:"195";s:5:" да";s:3:"196";s:5:" зо";s:3:"197";s:5:"vрэ";s:3:"198";s:6:"аад";s:3:"199";s:6:"гээ";s:3:"200";s:6:"лэн";s:3:"201";s:5:"н и";s:3:"202";s:5:"н э";s:3:"203";s:6:"нга";s:3:"204";s:5:"нэ ";s:3:"205";s:6:"тал";s:3:"206";s:6:"тын";s:3:"207";s:6:"хур";s:3:"208";s:5:"эл ";s:3:"209";s:5:" на";s:3:"210";s:5:" ни";s:3:"211";s:5:" он";s:3:"212";s:5:"vлэ";s:3:"213";s:5:"аг ";s:3:"214";s:5:"аж ";s:3:"215";s:5:"ай ";s:3:"216";s:6:"ата";s:3:"217";s:6:"бар";s:3:"218";s:5:"г б";s:3:"219";s:6:"гад";s:3:"220";s:6:"гїй";s:3:"221";s:5:"й х";s:3:"222";s:5:"лт ";s:3:"223";s:5:"н м";s:3:"224";s:5:"на ";s:3:"225";s:6:"оро";s:3:"226";s:6:"уль";s:3:"227";s:6:"чин";s:3:"228";s:5:"эж ";s:3:"229";s:6:"энэ";s:3:"230";s:6:"ээд";s:3:"231";s:5:"їй ";s:3:"232";s:6:"їлэ";s:3:"233";s:5:" би";s:3:"234";s:5:" тэ";s:3:"235";s:5:" эн";s:3:"236";s:6:"аны";s:3:"237";s:6:"дий";s:3:"238";s:6:"дээ";s:3:"239";s:6:"лал";s:3:"240";s:6:"лга";s:3:"241";s:5:"лд ";s:3:"242";s:6:"лог";s:3:"243";s:5:"ль ";s:3:"244";s:5:"н у";s:3:"245";s:5:"н ї";s:3:"246";s:5:"р б";s:3:"247";s:6:"рал";s:3:"248";s:6:"сон";s:3:"249";s:6:"тай";s:3:"250";s:6:"удл";s:3:"251";s:6:"элт";s:3:"252";s:6:"эрг";s:3:"253";s:6:"єлє";s:3:"254";s:4:" vй";s:3:"255";s:4:" в ";s:3:"256";s:5:" гэ";s:3:"257";s:4:" хv";s:3:"258";s:6:"ара";s:3:"259";s:5:"бvр";s:3:"260";s:5:"д н";s:3:"261";s:5:"д о";s:3:"262";s:5:"л х";s:3:"263";s:5:"лс ";s:3:"264";s:6:"лты";s:3:"265";s:5:"н г";s:3:"266";s:6:"нэг";s:3:"267";s:6:"огт";s:3:"268";s:6:"олы";s:3:"269";s:6:"оёр";s:3:"270";s:5:"р т";s:3:"271";s:6:"рээ";s:3:"272";s:6:"тав";s:3:"273";s:6:"тог";s:3:"274";s:6:"уур";s:3:"275";s:6:"хоё";s:3:"276";s:6:"хэл";s:3:"277";s:6:"хээ";s:3:"278";s:6:"элэ";s:3:"279";s:5:"ёр ";s:3:"280";s:5:" ав";s:3:"281";s:5:" ас";s:3:"282";s:5:" аш";s:3:"283";s:5:" ду";s:3:"284";s:5:" со";s:3:"285";s:5:" чи";s:3:"286";s:5:" эв";s:3:"287";s:5:" єр";s:3:"288";s:6:"аал";s:3:"289";s:6:"алд";s:3:"290";s:6:"амж";s:3:"291";s:6:"анд";s:3:"292";s:6:"асу";s:3:"293";s:6:"вэр";s:3:"294";s:5:"г у";s:3:"295";s:6:"двэ";s:3:"296";s:4:"жvv";s:3:"297";s:6:"лца";s:3:"298";s:6:"лэл";s:3:"299";}s:6:"nepali";a:300:{s:7:"को ";s:1:"0";s:7:"का ";s:1:"1";s:7:"मा ";s:1:"2";s:9:"हरु";s:1:"3";s:7:" ने";s:1:"4";s:9:"नेप";s:1:"5";s:9:"पाल";s:1:"6";s:9:"ेपा";s:1:"7";s:7:" सम";s:1:"8";s:7:"ले ";s:1:"9";s:7:" प्";s:2:"10";s:9:"प्र";s:2:"11";s:9:"कार";s:2:"12";s:7:"ा स";s:2:"13";s:9:"एको";s:2:"14";s:7:" भए";s:2:"15";s:5:" छ ";s:2:"16";s:7:" भा";s:2:"17";s:9:"्रम";s:2:"18";s:7:" गर";s:2:"19";s:9:"रुक";s:2:"20";s:5:" र ";s:2:"21";s:9:"भार";s:2:"22";s:9:"ारत";s:2:"23";s:7:" का";s:2:"24";s:7:" वि";s:2:"25";s:9:"भएक";s:2:"26";s:9:"ाली";s:2:"27";s:7:"ली ";s:2:"28";s:7:"ा प";s:2:"29";s:9:"ीहर";s:2:"30";s:9:"ार्";s:2:"31";s:7:"ो छ";s:2:"32";s:7:"ना ";s:2:"33";s:7:"रु ";s:2:"34";s:9:"ालक";s:2:"35";s:9:"्या";s:2:"36";s:7:" बा";s:2:"37";s:9:"एका";s:2:"38";s:7:"ने ";s:2:"39";s:9:"न्त";s:2:"40";s:7:"ा ब";s:2:"41";s:9:"ाको";s:2:"42";s:7:"ार ";s:2:"43";s:7:"ा भ";s:2:"44";s:9:"ाहर";s:2:"45";s:9:"्रो";s:2:"46";s:9:"क्ष";s:2:"47";s:7:"न् ";s:2:"48";s:9:"ारी";s:2:"49";s:7:" नि";s:2:"50";s:7:"ा न";s:2:"51";s:7:"ी स";s:2:"52";s:7:" डु";s:2:"53";s:9:"क्र";s:2:"54";s:9:"जना";s:2:"55";s:7:"यो ";s:2:"56";s:7:"ा छ";s:2:"57";s:9:"ेवा";s:2:"58";s:9:"्ता";s:2:"59";s:7:" रा";s:2:"60";s:9:"त्य";s:2:"61";s:9:"न्द";s:2:"62";s:9:"हुन";s:2:"63";s:7:"ा क";s:2:"64";s:9:"ामा";s:2:"65";s:7:"ी न";s:2:"66";s:9:"्दा";s:2:"67";s:7:" से";s:2:"68";s:9:"छन्";s:2:"69";s:9:"म्ब";s:2:"70";s:9:"रोत";s:2:"71";s:9:"सेव";s:2:"72";s:9:"स्त";s:2:"73";s:9:"स्र";s:2:"74";s:9:"ेका";s:2:"75";s:7:"्त ";s:2:"76";s:7:" बी";s:2:"77";s:7:" हु";s:2:"78";s:9:"क्त";s:2:"79";s:9:"त्र";s:2:"80";s:7:"रत ";s:2:"81";s:9:"र्न";s:2:"82";s:9:"र्य";s:2:"83";s:7:"ा र";s:2:"84";s:9:"ाका";s:2:"85";s:9:"ुको";s:2:"86";s:7:" एक";s:2:"87";s:7:" सं";s:2:"88";s:7:" सु";s:2:"89";s:9:"बीब";s:2:"90";s:9:"बीस";s:2:"91";s:9:"लको";s:2:"92";s:9:"स्य";s:2:"93";s:9:"ीबी";s:2:"94";s:9:"ीसी";s:2:"95";s:9:"ेको";s:2:"96";s:7:"ो स";s:2:"97";s:9:"्यक";s:2:"98";s:7:" छन";s:2:"99";s:7:" जन";s:3:"100";s:7:" बि";s:3:"101";s:7:" मु";s:3:"102";s:7:" स्";s:3:"103";s:9:"गर्";s:3:"104";s:9:"ताह";s:3:"105";s:9:"न्ध";s:3:"106";s:9:"बार";s:3:"107";s:9:"मन्";s:3:"108";s:9:"मस्";s:3:"109";s:9:"रुल";s:3:"110";s:9:"लाई";s:3:"111";s:7:"ा व";s:3:"112";s:7:"ाई ";s:3:"113";s:7:"ाल ";s:3:"114";s:9:"िका";s:3:"115";s:7:" त्";s:3:"116";s:7:" मा";s:3:"117";s:7:" यस";s:3:"118";s:7:" रु";s:3:"119";s:9:"ताक";s:3:"120";s:9:"बन्";s:3:"121";s:7:"र ब";s:3:"122";s:7:"रण ";s:3:"123";s:9:"रुप";s:3:"124";s:9:"रेक";s:3:"125";s:9:"ष्ट";s:3:"126";s:9:"सम्";s:3:"127";s:7:"सी ";s:3:"128";s:9:"ाएक";s:3:"129";s:9:"ुका";s:3:"130";s:9:"ुक्";s:3:"131";s:7:" अध";s:3:"132";s:7:" अन";s:3:"133";s:7:" तथ";s:3:"134";s:7:" थि";s:3:"135";s:7:" दे";s:3:"136";s:7:" पर";s:3:"137";s:7:" बै";s:3:"138";s:9:"तथा";s:3:"139";s:7:"ता ";s:3:"140";s:7:"दा ";s:3:"141";s:9:"द्द";s:3:"142";s:7:"नी ";s:3:"143";s:9:"बाट";s:3:"144";s:9:"यक्";s:3:"145";s:7:"री ";s:3:"146";s:9:"रीह";s:3:"147";s:9:"र्म";s:3:"148";s:9:"लका";s:3:"149";s:9:"समस";s:3:"150";s:7:"ा अ";s:3:"151";s:7:"ा ए";s:3:"152";s:7:"ाट ";s:3:"153";s:7:"िय ";s:3:"154";s:7:"ो प";s:3:"155";s:7:"ो म";s:3:"156";s:7:"्न ";s:3:"157";s:9:"्ने";s:3:"158";s:9:"्षा";s:3:"159";s:7:" पा";s:3:"160";s:7:" यो";s:3:"161";s:7:" हा";s:3:"162";s:9:"अधि";s:3:"163";s:9:"डुव";s:3:"164";s:7:"त भ";s:3:"165";s:7:"त स";s:3:"166";s:7:"था ";s:3:"167";s:9:"धिक";s:3:"168";s:9:"पमा";s:3:"169";s:9:"बैठ";s:3:"170";s:9:"मुद";s:3:"171";s:7:"या ";s:3:"172";s:9:"युक";s:3:"173";s:7:"र न";s:3:"174";s:9:"रति";s:3:"175";s:9:"वान";s:3:"176";s:9:"सार";s:3:"177";s:7:"ा आ";s:3:"178";s:7:"ा ज";s:3:"179";s:7:"ा ह";s:3:"180";s:9:"ुद्";s:3:"181";s:9:"ुपम";s:3:"182";s:9:"ुले";s:3:"183";s:9:"ुवा";s:3:"184";s:9:"ैठक";s:3:"185";s:7:"ो ब";s:3:"186";s:9:"्तर";s:3:"187";s:7:"्य ";s:3:"188";s:9:"्यस";s:3:"189";s:7:" क्";s:3:"190";s:7:" मन";s:3:"191";s:7:" रह";s:3:"192";s:9:"चार";s:3:"193";s:9:"तिय";s:3:"194";s:7:"दै ";s:3:"195";s:9:"निर";s:3:"196";s:7:"नु ";s:3:"197";s:9:"पर्";s:3:"198";s:9:"रक्";s:3:"199";s:9:"र्द";s:3:"200";s:9:"समा";s:3:"201";s:9:"सुर";s:3:"202";s:9:"ाउन";s:3:"203";s:7:"ान ";s:3:"204";s:9:"ानम";s:3:"205";s:9:"ारण";s:3:"206";s:9:"ाले";s:3:"207";s:7:"ि ब";s:3:"208";s:9:"ियो";s:3:"209";s:9:"ुन्";s:3:"210";s:9:"ुरक";s:3:"211";s:9:"्त्";s:3:"212";s:9:"्बन";s:3:"213";s:9:"्रा";s:3:"214";s:7:"्ष ";s:3:"215";s:7:" आर";s:3:"216";s:7:" जल";s:3:"217";s:7:" बे";s:3:"218";s:7:" या";s:3:"219";s:7:" सा";s:3:"220";s:9:"आएक";s:3:"221";s:7:"एक ";s:3:"222";s:9:"कर्";s:3:"223";s:9:"जलस";s:3:"224";s:9:"णका";s:3:"225";s:7:"त र";s:3:"226";s:9:"द्र";s:3:"227";s:9:"धान";s:3:"228";s:7:"धि ";s:3:"229";s:9:"नका";s:3:"230";s:9:"नमा";s:3:"231";s:7:"नि ";s:3:"232";s:9:"ममा";s:3:"233";s:7:"रम ";s:3:"234";s:9:"रहे";s:3:"235";s:9:"राज";s:3:"236";s:9:"लस्";s:3:"237";s:7:"ला ";s:3:"238";s:9:"वार";s:3:"239";s:9:"सका";s:3:"240";s:9:"हिल";s:3:"241";s:9:"हेक";s:3:"242";s:7:"ा त";s:3:"243";s:9:"ारे";s:3:"244";s:9:"िन्";s:3:"245";s:9:"िस्";s:3:"246";s:7:"े स";s:3:"247";s:7:"ो न";s:3:"248";s:7:"ो र";s:3:"249";s:7:"ोत ";s:3:"250";s:9:"्धि";s:3:"251";s:9:"्मी";s:3:"252";s:9:"्रस";s:3:"253";s:7:" दु";s:3:"254";s:7:" पन";s:3:"255";s:7:" बत";s:3:"256";s:7:" बन";s:3:"257";s:7:" भन";s:3:"258";s:9:"ंयु";s:3:"259";s:9:"आरम";s:3:"260";s:7:"खि ";s:3:"261";s:9:"ण्ड";s:3:"262";s:9:"तका";s:3:"263";s:9:"ताल";s:3:"264";s:7:"दी ";s:3:"265";s:9:"देख";s:3:"266";s:9:"निय";s:3:"267";s:9:"पनि";s:3:"268";s:9:"प्त";s:3:"269";s:9:"बता";s:3:"270";s:7:"मी ";s:3:"271";s:9:"म्भ";s:3:"272";s:7:"र स";s:3:"273";s:9:"रम्";s:3:"274";s:9:"लमा";s:3:"275";s:9:"विश";s:3:"276";s:9:"षाक";s:3:"277";s:9:"संय";s:3:"278";s:7:"ा ड";s:3:"279";s:7:"ा म";s:3:"280";s:9:"ानक";s:3:"281";s:9:"ालम";s:3:"282";s:7:"ि भ";s:3:"283";s:7:"ित ";s:3:"284";s:7:"ी प";s:3:"285";s:7:"ी र";s:3:"286";s:7:"ु भ";s:3:"287";s:9:"ुने";s:3:"288";s:7:"े ग";s:3:"289";s:9:"ेखि";s:3:"290";s:7:"ेर ";s:3:"291";s:7:"ो भ";s:3:"292";s:7:"ो व";s:3:"293";s:7:"ो ह";s:3:"294";s:7:"्भ ";s:3:"295";s:7:"्र ";s:3:"296";s:7:" ता";s:3:"297";s:7:" नम";s:3:"298";s:7:" ना";s:3:"299";}s:9:"norwegian";a:300:{s:3:"er ";s:1:"0";s:3:"en ";s:1:"1";s:3:"et ";s:1:"2";s:3:" de";s:1:"3";s:3:"det";s:1:"4";s:3:" i ";s:1:"5";s:3:"for";s:1:"6";s:3:"il ";s:1:"7";s:3:" fo";s:1:"8";s:3:" me";s:1:"9";s:3:"ing";s:2:"10";s:3:"om ";s:2:"11";s:3:" ha";s:2:"12";s:3:" og";s:2:"13";s:3:"ter";s:2:"14";s:3:" er";s:2:"15";s:3:" ti";s:2:"16";s:3:" st";s:2:"17";s:3:"og ";s:2:"18";s:3:"til";s:2:"19";s:3:"ne ";s:2:"20";s:3:" vi";s:2:"21";s:3:"re ";s:2:"22";s:3:" en";s:2:"23";s:3:" se";s:2:"24";s:3:"te ";s:2:"25";s:3:"or ";s:2:"26";s:3:"de ";s:2:"27";s:3:"kke";s:2:"28";s:3:"ke ";s:2:"29";s:3:"ar ";s:2:"30";s:3:"ng ";s:2:"31";s:3:"r s";s:2:"32";s:3:"ene";s:2:"33";s:3:" so";s:2:"34";s:3:"e s";s:2:"35";s:3:"der";s:2:"36";s:3:"an ";s:2:"37";s:3:"som";s:2:"38";s:3:"ste";s:2:"39";s:3:"at ";s:2:"40";s:3:"ed ";s:2:"41";s:3:"r i";s:2:"42";s:3:" av";s:2:"43";s:3:" in";s:2:"44";s:3:"men";s:2:"45";s:3:" at";s:2:"46";s:3:" ko";s:2:"47";s:4:" på";s:2:"48";s:3:"har";s:2:"49";s:3:" si";s:2:"50";s:3:"ere";s:2:"51";s:4:"på ";s:2:"52";s:3:"nde";s:2:"53";s:3:"and";s:2:"54";s:3:"els";s:2:"55";s:3:"ett";s:2:"56";s:3:"tte";s:2:"57";s:3:"lig";s:2:"58";s:3:"t s";s:2:"59";s:3:"den";s:2:"60";s:3:"t i";s:2:"61";s:3:"ikk";s:2:"62";s:3:"med";s:2:"63";s:3:"n s";s:2:"64";s:3:"rt ";s:2:"65";s:3:"ser";s:2:"66";s:3:"ska";s:2:"67";s:3:"t e";s:2:"68";s:3:"ker";s:2:"69";s:3:"sen";s:2:"70";s:3:"av ";s:2:"71";s:3:"ler";s:2:"72";s:3:"r a";s:2:"73";s:3:"ten";s:2:"74";s:3:"e f";s:2:"75";s:3:"r e";s:2:"76";s:3:"r t";s:2:"77";s:3:"ede";s:2:"78";s:3:"ig ";s:2:"79";s:3:" re";s:2:"80";s:3:"han";s:2:"81";s:3:"lle";s:2:"82";s:3:"ner";s:2:"83";s:3:" bl";s:2:"84";s:3:" fr";s:2:"85";s:3:"le ";s:2:"86";s:3:" ve";s:2:"87";s:3:"e t";s:2:"88";s:3:"lan";s:2:"89";s:3:"mme";s:2:"90";s:3:"nge";s:2:"91";s:3:" be";s:2:"92";s:3:" ik";s:2:"93";s:3:" om";s:2:"94";s:4:" å ";s:2:"95";s:3:"ell";s:2:"96";s:3:"sel";s:2:"97";s:3:"sta";s:2:"98";s:3:"ver";s:2:"99";s:3:" et";s:3:"100";s:3:" sk";s:3:"101";s:3:"nte";s:3:"102";s:3:"one";s:3:"103";s:3:"ore";s:3:"104";s:3:"r d";s:3:"105";s:3:"ske";s:3:"106";s:3:" an";s:3:"107";s:3:" la";s:3:"108";s:3:"del";s:3:"109";s:3:"gen";s:3:"110";s:3:"nin";s:3:"111";s:3:"r f";s:3:"112";s:3:"r v";s:3:"113";s:3:"se ";s:3:"114";s:3:" po";s:3:"115";s:3:"ir ";s:3:"116";s:3:"jon";s:3:"117";s:3:"mer";s:3:"118";s:3:"nen";s:3:"119";s:3:"omm";s:3:"120";s:3:"sjo";s:3:"121";s:3:" fl";s:3:"122";s:3:" sa";s:3:"123";s:3:"ern";s:3:"124";s:3:"kom";s:3:"125";s:3:"r m";s:3:"126";s:3:"r o";s:3:"127";s:3:"ren";s:3:"128";s:3:"vil";s:3:"129";s:3:"ale";s:3:"130";s:3:"es ";s:3:"131";s:3:"n a";s:3:"132";s:3:"t f";s:3:"133";s:3:" le";s:3:"134";s:3:"bli";s:3:"135";s:3:"e e";s:3:"136";s:3:"e i";s:3:"137";s:3:"e v";s:3:"138";s:3:"het";s:3:"139";s:3:"ye ";s:3:"140";s:3:" ir";s:3:"141";s:3:"al ";s:3:"142";s:3:"e o";s:3:"143";s:3:"ide";s:3:"144";s:3:"iti";s:3:"145";s:3:"lit";s:3:"146";s:3:"nne";s:3:"147";s:3:"ran";s:3:"148";s:3:"t o";s:3:"149";s:3:"tal";s:3:"150";s:3:"tat";s:3:"151";s:3:"tt ";s:3:"152";s:3:" ka";s:3:"153";s:3:"ans";s:3:"154";s:3:"asj";s:3:"155";s:3:"ge ";s:3:"156";s:3:"inn";s:3:"157";s:3:"kon";s:3:"158";s:3:"lse";s:3:"159";s:3:"pet";s:3:"160";s:3:"t d";s:3:"161";s:3:"vi ";s:3:"162";s:3:" ut";s:3:"163";s:3:"ent";s:3:"164";s:3:"eri";s:3:"165";s:3:"oli";s:3:"166";s:3:"r p";s:3:"167";s:3:"ret";s:3:"168";s:3:"ris";s:3:"169";s:3:"sto";s:3:"170";s:3:"str";s:3:"171";s:3:"t a";s:3:"172";s:3:" ga";s:3:"173";s:3:"all";s:3:"174";s:3:"ape";s:3:"175";s:3:"g s";s:3:"176";s:3:"ill";s:3:"177";s:3:"ira";s:3:"178";s:3:"kap";s:3:"179";s:3:"nn ";s:3:"180";s:3:"opp";s:3:"181";s:3:"r h";s:3:"182";s:3:"rin";s:3:"183";s:3:" br";s:3:"184";s:3:" op";s:3:"185";s:3:"e m";s:3:"186";s:3:"ert";s:3:"187";s:3:"ger";s:3:"188";s:3:"ion";s:3:"189";s:3:"kal";s:3:"190";s:3:"lsk";s:3:"191";s:3:"nes";s:3:"192";s:3:" gj";s:3:"193";s:3:" mi";s:3:"194";s:3:" pr";s:3:"195";s:3:"ang";s:3:"196";s:3:"e h";s:3:"197";s:3:"e r";s:3:"198";s:3:"elt";s:3:"199";s:3:"enn";s:3:"200";s:3:"i s";s:3:"201";s:3:"ist";s:3:"202";s:3:"jen";s:3:"203";s:3:"kan";s:3:"204";s:3:"lt ";s:3:"205";s:3:"nal";s:3:"206";s:3:"res";s:3:"207";s:3:"tor";s:3:"208";s:3:"ass";s:3:"209";s:3:"dre";s:3:"210";s:3:"e b";s:3:"211";s:3:"e p";s:3:"212";s:3:"mel";s:3:"213";s:3:"n t";s:3:"214";s:3:"nse";s:3:"215";s:3:"ort";s:3:"216";s:3:"per";s:3:"217";s:3:"reg";s:3:"218";s:3:"sje";s:3:"219";s:3:"t p";s:3:"220";s:3:"t v";s:3:"221";s:3:" hv";s:3:"222";s:4:" nå";s:3:"223";s:3:" va";s:3:"224";s:3:"ann";s:3:"225";s:3:"ato";s:3:"226";s:3:"e a";s:3:"227";s:3:"est";s:3:"228";s:3:"ise";s:3:"229";s:3:"isk";s:3:"230";s:3:"oil";s:3:"231";s:3:"ord";s:3:"232";s:3:"pol";s:3:"233";s:3:"ra ";s:3:"234";s:3:"rak";s:3:"235";s:3:"sse";s:3:"236";s:3:"toi";s:3:"237";s:3:" gr";s:3:"238";s:3:"ak ";s:3:"239";s:3:"eg ";s:3:"240";s:3:"ele";s:3:"241";s:3:"g a";s:3:"242";s:3:"ige";s:3:"243";s:3:"igh";s:3:"244";s:3:"m e";s:3:"245";s:3:"n f";s:3:"246";s:3:"n v";s:3:"247";s:3:"ndr";s:3:"248";s:3:"nsk";s:3:"249";s:3:"rer";s:3:"250";s:3:"t m";s:3:"251";s:3:"und";s:3:"252";s:3:"var";s:3:"253";s:4:"år ";s:3:"254";s:3:" he";s:3:"255";s:3:" no";s:3:"256";s:3:" ny";s:3:"257";s:3:"end";s:3:"258";s:3:"ete";s:3:"259";s:3:"fly";s:3:"260";s:3:"g i";s:3:"261";s:3:"ghe";s:3:"262";s:3:"ier";s:3:"263";s:3:"ind";s:3:"264";s:3:"int";s:3:"265";s:3:"lin";s:3:"266";s:3:"n d";s:3:"267";s:3:"n p";s:3:"268";s:3:"rne";s:3:"269";s:3:"sak";s:3:"270";s:3:"sie";s:3:"271";s:3:"t b";s:3:"272";s:3:"tid";s:3:"273";s:3:" al";s:3:"274";s:3:" pa";s:3:"275";s:3:" tr";s:3:"276";s:3:"ag ";s:3:"277";s:3:"dig";s:3:"278";s:3:"e d";s:3:"279";s:3:"e k";s:3:"280";s:3:"ess";s:3:"281";s:3:"hol";s:3:"282";s:3:"i d";s:3:"283";s:3:"lag";s:3:"284";s:3:"led";s:3:"285";s:3:"n e";s:3:"286";s:3:"n i";s:3:"287";s:3:"n o";s:3:"288";s:3:"pri";s:3:"289";s:3:"r b";s:3:"290";s:3:"st ";s:3:"291";s:3:" fe";s:3:"292";s:3:" li";s:3:"293";s:3:" ry";s:3:"294";s:3:"air";s:3:"295";s:3:"ake";s:3:"296";s:3:"d s";s:3:"297";s:3:"eas";s:3:"298";s:3:"egi";s:3:"299";}s:6:"pashto";a:300:{s:4:" د ";s:1:"0";s:5:"اؤ ";s:1:"1";s:5:" اؤ";s:1:"2";s:5:"نو ";s:1:"3";s:5:"ې د";s:1:"4";s:5:"ره ";s:1:"5";s:5:" په";s:1:"6";s:5:"نه ";s:1:"7";s:5:"چې ";s:1:"8";s:5:" چې";s:1:"9";s:5:"په ";s:2:"10";s:5:"ه د";s:2:"11";s:5:"ته ";s:2:"12";s:5:"و ا";s:2:"13";s:6:"ونو";s:2:"14";s:5:"و د";s:2:"15";s:5:" او";s:2:"16";s:6:"انو";s:2:"17";s:6:"ونه";s:2:"18";s:5:"ه ک";s:2:"19";s:5:" دا";s:2:"20";s:5:"ه ا";s:2:"21";s:5:"دې ";s:2:"22";s:5:"ښې ";s:2:"23";s:5:" کې";s:2:"24";s:5:"ان ";s:2:"25";s:5:"لو ";s:2:"26";s:5:"هم ";s:2:"27";s:5:"و م";s:2:"28";s:6:"کښې";s:2:"29";s:5:"ه م";s:2:"30";s:5:"ى ا";s:2:"31";s:5:" نو";s:2:"32";s:5:" ته";s:2:"33";s:5:" کښ";s:2:"34";s:6:"رون";s:2:"35";s:5:"کې ";s:2:"36";s:5:"ده ";s:2:"37";s:5:"له ";s:2:"38";s:5:"به ";s:2:"39";s:5:"رو ";s:2:"40";s:5:" هم";s:2:"41";s:5:"ه و";s:2:"42";s:5:"وى ";s:2:"43";s:5:"او ";s:2:"44";s:6:"تون";s:2:"45";s:5:"دا ";s:2:"46";s:5:" کو";s:2:"47";s:5:" کړ";s:2:"48";s:6:"قام";s:2:"49";s:5:" تر";s:2:"50";s:6:"ران";s:2:"51";s:5:"ه پ";s:2:"52";s:5:"ې و";s:2:"53";s:5:"ې پ";s:2:"54";s:5:" به";s:2:"55";s:5:" خو";s:2:"56";s:5:"تو ";s:2:"57";s:5:"د د";s:2:"58";s:5:"د ا";s:2:"59";s:5:"ه ت";s:2:"60";s:5:"و پ";s:2:"61";s:5:"يا ";s:2:"62";s:5:" خپ";s:2:"63";s:5:" دو";s:2:"64";s:5:" را";s:2:"65";s:5:" مش";s:2:"66";s:5:" پر";s:2:"67";s:6:"ارو";s:2:"68";s:5:"رې ";s:2:"69";s:5:"م د";s:2:"70";s:6:"مشر";s:2:"71";s:5:" شو";s:2:"72";s:5:" ور";s:2:"73";s:5:"ار ";s:2:"74";s:5:"دى ";s:2:"75";s:5:" اد";s:2:"76";s:5:" دى";s:2:"77";s:5:" مو";s:2:"78";s:5:"د پ";s:2:"79";s:5:"لي ";s:2:"80";s:5:"و ک";s:2:"81";s:5:" مق";s:2:"82";s:5:" يو";s:2:"83";s:5:"ؤ د";s:2:"84";s:6:"خپل";s:2:"85";s:6:"سره";s:2:"86";s:5:"ه چ";s:2:"87";s:5:"ور ";s:2:"88";s:5:" تا";s:2:"89";s:5:" دې";s:2:"90";s:5:" رو";s:2:"91";s:5:" سر";s:2:"92";s:5:" مل";s:2:"93";s:5:" کا";s:2:"94";s:5:"ؤ ا";s:2:"95";s:6:"اره";s:2:"96";s:6:"برو";s:2:"97";s:5:"مه ";s:2:"98";s:5:"ه ب";s:2:"99";s:5:"و ت";s:3:"100";s:6:"پښت";s:3:"101";s:5:" با";s:3:"102";s:5:" دغ";s:3:"103";s:5:" قب";s:3:"104";s:5:" له";s:3:"105";s:5:" وا";s:3:"106";s:5:" پا";s:3:"107";s:5:" پښ";s:3:"108";s:5:"د م";s:3:"109";s:5:"د ه";s:3:"110";s:5:"لې ";s:3:"111";s:6:"مات";s:3:"112";s:5:"مو ";s:3:"113";s:5:"ه ه";s:3:"114";s:5:"وي ";s:3:"115";s:5:"ې ب";s:3:"116";s:5:"ې ک";s:3:"117";s:5:" ده";s:3:"118";s:5:" قا";s:3:"119";s:5:"ال ";s:3:"120";s:6:"اما";s:3:"121";s:5:"د ن";s:3:"122";s:6:"قبر";s:3:"123";s:5:"ه ن";s:3:"124";s:6:"پار";s:3:"125";s:5:" اث";s:3:"126";s:5:" بي";s:3:"127";s:5:" لا";s:3:"128";s:5:" لر";s:3:"129";s:6:"اثا";s:3:"130";s:5:"د خ";s:3:"131";s:6:"دار";s:3:"132";s:6:"ريخ";s:3:"133";s:6:"شرا";s:3:"134";s:6:"مقا";s:3:"135";s:5:"نۍ ";s:3:"136";s:5:"ه ر";s:3:"137";s:5:"ه ل";s:3:"138";s:6:"ولو";s:3:"139";s:5:"يو ";s:3:"140";s:6:"کوم";s:3:"141";s:5:" دد";s:3:"142";s:5:" لو";s:3:"143";s:5:" مح";s:3:"144";s:5:" مر";s:3:"145";s:5:" وو";s:3:"146";s:6:"اتو";s:3:"147";s:6:"اري";s:3:"148";s:6:"الو";s:3:"149";s:6:"اند";s:3:"150";s:6:"خان";s:3:"151";s:5:"د ت";s:3:"152";s:5:"سې ";s:3:"153";s:5:"لى ";s:3:"154";s:6:"نور";s:3:"155";s:5:"و ل";s:3:"156";s:5:"ي چ";s:3:"157";s:5:"ړي ";s:3:"158";s:6:"ښتو";s:3:"159";s:5:"ې ل";s:3:"160";s:5:" جو";s:3:"161";s:5:" سي";s:3:"162";s:5:"ام ";s:3:"163";s:6:"بان";s:3:"164";s:6:"تار";s:3:"165";s:5:"تر ";s:3:"166";s:6:"ثار";s:3:"167";s:5:"خو ";s:3:"168";s:5:"دو ";s:3:"169";s:5:"ر ک";s:3:"170";s:5:"ل د";s:3:"171";s:6:"مون";s:3:"172";s:6:"ندې";s:3:"173";s:5:"و ن";s:3:"174";s:5:"ول ";s:3:"175";s:5:"وه ";s:3:"176";s:5:"ى و";s:3:"177";s:5:"ي د";s:3:"178";s:5:"ې ا";s:3:"179";s:5:"ې ت";s:3:"180";s:5:"ې ي";s:3:"181";s:5:" حک";s:3:"182";s:5:" خب";s:3:"183";s:5:" نه";s:3:"184";s:5:" پو";s:3:"185";s:5:"ا د";s:3:"186";s:5:"تې ";s:3:"187";s:6:"جوړ";s:3:"188";s:6:"حکم";s:3:"189";s:6:"حکو";s:3:"190";s:6:"خبر";s:3:"191";s:6:"دان";s:3:"192";s:5:"ر د";s:3:"193";s:5:"غه ";s:3:"194";s:6:"قاف";s:3:"195";s:6:"محک";s:3:"196";s:6:"وال";s:3:"197";s:6:"ومت";s:3:"198";s:6:"ويل";s:3:"199";s:5:"ى د";s:3:"200";s:5:"ى م";s:3:"201";s:6:"يره";s:3:"202";s:5:"پر ";s:3:"203";s:6:"کول";s:3:"204";s:5:"ې ه";s:3:"205";s:5:" تي";s:3:"206";s:5:" خا";s:3:"207";s:5:" وک";s:3:"208";s:5:" يا";s:3:"209";s:5:" ځا";s:3:"210";s:5:"ؤ ق";s:3:"211";s:6:"انۍ";s:3:"212";s:5:"بى ";s:3:"213";s:5:"غو ";s:3:"214";s:5:"ه خ";s:3:"215";s:5:"و ب";s:3:"216";s:6:"ودا";s:3:"217";s:6:"يدو";s:3:"218";s:5:"ړې ";s:3:"219";s:6:"کال";s:3:"220";s:5:" بر";s:3:"221";s:5:" قد";s:3:"222";s:5:" مي";s:3:"223";s:5:" وي";s:3:"224";s:5:" کر";s:3:"225";s:5:"ؤ م";s:3:"226";s:5:"ات ";s:3:"227";s:6:"ايي";s:3:"228";s:5:"تى ";s:3:"229";s:6:"تيا";s:3:"230";s:6:"تير";s:3:"231";s:6:"خوا";s:3:"232";s:6:"دغو";s:3:"233";s:5:"دم ";s:3:"234";s:6:"ديم";s:3:"235";s:5:"ر و";s:3:"236";s:6:"قدي";s:3:"237";s:5:"م خ";s:3:"238";s:6:"مان";s:3:"239";s:5:"مې ";s:3:"240";s:6:"نيو";s:3:"241";s:5:"نږ ";s:3:"242";s:5:"ه ي";s:3:"243";s:5:"و س";s:3:"244";s:5:"و چ";s:3:"245";s:6:"وان";s:3:"246";s:6:"ورو";s:3:"247";s:6:"ونږ";s:3:"248";s:6:"پور";s:3:"249";s:5:"ړه ";s:3:"250";s:5:"ړو ";s:3:"251";s:5:"ۍ د";s:3:"252";s:5:"ې ن";s:3:"253";s:5:" اه";s:3:"254";s:5:" زي";s:3:"255";s:5:" سو";s:3:"256";s:5:" شي";s:3:"257";s:5:" هر";s:3:"258";s:5:" هغ";s:3:"259";s:5:" ښا";s:3:"260";s:6:"اتل";s:3:"261";s:5:"اق ";s:3:"262";s:6:"اني";s:3:"263";s:6:"بري";s:3:"264";s:5:"بې ";s:3:"265";s:5:"ت ا";s:3:"266";s:5:"د ب";s:3:"267";s:5:"د س";s:3:"268";s:5:"ر م";s:3:"269";s:5:"رى ";s:3:"270";s:6:"عرا";s:3:"271";s:6:"لان";s:3:"272";s:5:"مى ";s:3:"273";s:5:"نى ";s:3:"274";s:5:"و خ";s:3:"275";s:5:"وئ ";s:3:"276";s:6:"ورک";s:3:"277";s:6:"ورې";s:3:"278";s:5:"ون ";s:3:"279";s:6:"وکړ";s:3:"280";s:5:"ى چ";s:3:"281";s:6:"يمه";s:3:"282";s:5:"يې ";s:3:"283";s:6:"ښتن";s:3:"284";s:5:"که ";s:3:"285";s:6:"کړي";s:3:"286";s:5:"ې خ";s:3:"287";s:5:"ے ش";s:3:"288";s:5:" تح";s:3:"289";s:5:" تو";s:3:"290";s:5:" در";s:3:"291";s:5:" دپ";s:3:"292";s:5:" صو";s:3:"293";s:5:" عر";s:3:"294";s:5:" ول";s:3:"295";s:5:" يؤ";s:3:"296";s:5:" پۀ";s:3:"297";s:5:" څو";s:3:"298";s:5:"ا ا";s:3:"299";}s:6:"pidgin";a:300:{s:3:" de";s:1:"0";s:3:" we";s:1:"1";s:3:" di";s:1:"2";s:3:"di ";s:1:"3";s:3:"dem";s:1:"4";s:3:"em ";s:1:"5";s:3:"ay ";s:1:"6";s:3:" sa";s:1:"7";s:3:"or ";s:1:"8";s:3:"say";s:1:"9";s:3:"ke ";s:2:"10";s:3:"ey ";s:2:"11";s:3:" an";s:2:"12";s:3:" go";s:2:"13";s:3:" e ";s:2:"14";s:3:" to";s:2:"15";s:3:" ma";s:2:"16";s:3:"e d";s:2:"17";s:3:"wey";s:2:"18";s:3:"for";s:2:"19";s:3:"nd ";s:2:"20";s:3:"to ";s:2:"21";s:3:" be";s:2:"22";s:3:" fo";s:2:"23";s:3:"ake";s:2:"24";s:3:"im ";s:2:"25";s:3:" pe";s:2:"26";s:3:"le ";s:2:"27";s:3:"go ";s:2:"28";s:3:"ll ";s:2:"29";s:3:"de ";s:2:"30";s:3:"e s";s:2:"31";s:3:"on ";s:2:"32";s:3:"get";s:2:"33";s:3:"ght";s:2:"34";s:3:"igh";s:2:"35";s:3:" ri";s:2:"36";s:3:"et ";s:2:"37";s:3:"rig";s:2:"38";s:3:" ge";s:2:"39";s:3:"y d";s:2:"40";s:3:" na";s:2:"41";s:3:"mak";s:2:"42";s:3:"t t";s:2:"43";s:3:" no";s:2:"44";s:3:"and";s:2:"45";s:3:"tin";s:2:"46";s:3:"ing";s:2:"47";s:3:"eve";s:2:"48";s:3:"ri ";s:2:"49";s:3:" im";s:2:"50";s:3:" am";s:2:"51";s:3:" or";s:2:"52";s:3:"am ";s:2:"53";s:3:"be ";s:2:"54";s:3:" ev";s:2:"55";s:3:" ta";s:2:"56";s:3:"ht ";s:2:"57";s:3:"e w";s:2:"58";s:3:" li";s:2:"59";s:3:"eri";s:2:"60";s:3:"ng ";s:2:"61";s:3:"ver";s:2:"62";s:3:"all";s:2:"63";s:3:"e f";s:2:"64";s:3:"ers";s:2:"65";s:3:"ntr";s:2:"66";s:3:"ont";s:2:"67";s:3:" do";s:2:"68";s:3:"r d";s:2:"69";s:3:" ko";s:2:"70";s:3:" ti";s:2:"71";s:3:"an ";s:2:"72";s:3:"kon";s:2:"73";s:3:"per";s:2:"74";s:3:"tri";s:2:"75";s:3:"y e";s:2:"76";s:3:"rso";s:2:"77";s:3:"son";s:2:"78";s:3:"no ";s:2:"79";s:3:"ome";s:2:"80";s:3:"is ";s:2:"81";s:3:"do ";s:2:"82";s:3:"ne ";s:2:"83";s:3:"one";s:2:"84";s:3:"ion";s:2:"85";s:3:"m g";s:2:"86";s:3:"i k";s:2:"87";s:3:" al";s:2:"88";s:3:"bod";s:2:"89";s:3:"i w";s:2:"90";s:3:"odi";s:2:"91";s:3:" so";s:2:"92";s:3:" wo";s:2:"93";s:3:"o d";s:2:"94";s:3:"st ";s:2:"95";s:3:"t r";s:2:"96";s:3:" of";s:2:"97";s:3:"aim";s:2:"98";s:3:"e g";s:2:"99";s:3:"nai";s:3:"100";s:3:" co";s:3:"101";s:3:"dis";s:3:"102";s:3:"me ";s:3:"103";s:3:"of ";s:3:"104";s:3:" wa";s:3:"105";s:3:"e t";s:3:"106";s:3:" ar";s:3:"107";s:3:"e l";s:3:"108";s:3:"ike";s:3:"109";s:3:"lik";s:3:"110";s:3:"t a";s:3:"111";s:3:"wor";s:3:"112";s:3:"alk";s:3:"113";s:3:"ell";s:3:"114";s:3:"eop";s:3:"115";s:3:"lk ";s:3:"116";s:3:"opl";s:3:"117";s:3:"peo";s:3:"118";s:3:"ple";s:3:"119";s:3:"re ";s:3:"120";s:3:"tal";s:3:"121";s:3:"any";s:3:"122";s:3:"e a";s:3:"123";s:3:"o g";s:3:"124";s:3:"art";s:3:"125";s:3:"cle";s:3:"126";s:3:"i p";s:3:"127";s:3:"icl";s:3:"128";s:3:"rti";s:3:"129";s:3:"the";s:3:"130";s:3:"tic";s:3:"131";s:3:"we ";s:3:"132";s:3:"f d";s:3:"133";s:3:"in ";s:3:"134";s:3:" mu";s:3:"135";s:3:"e n";s:3:"136";s:3:"e o";s:3:"137";s:3:"mus";s:3:"138";s:3:"n d";s:3:"139";s:3:"na ";s:3:"140";s:3:"o m";s:3:"141";s:3:"ust";s:3:"142";s:3:"wel";s:3:"143";s:3:"e e";s:3:"144";s:3:"her";s:3:"145";s:3:"m d";s:3:"146";s:3:"nt ";s:3:"147";s:3:" fi";s:3:"148";s:3:"at ";s:3:"149";s:3:"e b";s:3:"150";s:3:"it ";s:3:"151";s:3:"m w";s:3:"152";s:3:"o t";s:3:"153";s:3:"wan";s:3:"154";s:3:"com";s:3:"155";s:3:"da ";s:3:"156";s:3:"fit";s:3:"157";s:3:"m b";s:3:"158";s:3:"so ";s:3:"159";s:3:" fr";s:3:"160";s:3:"ce ";s:3:"161";s:3:"er ";s:3:"162";s:3:"o a";s:3:"163";s:3:" if";s:3:"164";s:3:" on";s:3:"165";s:3:"ent";s:3:"166";s:3:"if ";s:3:"167";s:3:"ind";s:3:"168";s:3:"kin";s:3:"169";s:3:"l d";s:3:"170";s:3:"man";s:3:"171";s:3:"o s";s:3:"172";s:3:" se";s:3:"173";s:3:"y a";s:3:"174";s:3:"y m";s:3:"175";s:3:" re";s:3:"176";s:3:"ee ";s:3:"177";s:3:"k a";s:3:"178";s:3:"t s";s:3:"179";s:3:"ve ";s:3:"180";s:3:"y w";s:3:"181";s:3:" ki";s:3:"182";s:3:"eti";s:3:"183";s:3:"men";s:3:"184";s:3:"ta ";s:3:"185";s:3:"y n";s:3:"186";s:3:"d t";s:3:"187";s:3:"dey";s:3:"188";s:3:"e c";s:3:"189";s:3:"i o";s:3:"190";s:3:"ibo";s:3:"191";s:3:"ld ";s:3:"192";s:3:"m t";s:3:"193";s:3:"n b";s:3:"194";s:3:"o b";s:3:"195";s:3:"ow ";s:3:"196";s:3:"ree";s:3:"197";s:3:"rio";s:3:"198";s:3:"t d";s:3:"199";s:3:" hu";s:3:"200";s:3:" su";s:3:"201";s:3:"en ";s:3:"202";s:3:"hts";s:3:"203";s:3:"ive";s:3:"204";s:3:"m n";s:3:"205";s:3:"n g";s:3:"206";s:3:"ny ";s:3:"207";s:3:"oth";s:3:"208";s:3:"ts ";s:3:"209";s:3:" as";s:3:"210";s:3:" wh";s:3:"211";s:3:"as ";s:3:"212";s:3:"gom";s:3:"213";s:3:"hum";s:3:"214";s:3:"k s";s:3:"215";s:3:"oda";s:3:"216";s:3:"ork";s:3:"217";s:3:"se ";s:3:"218";s:3:"uma";s:3:"219";s:3:"ut ";s:3:"220";s:3:" ba";s:3:"221";s:3:" ot";s:3:"222";s:3:"ano";s:3:"223";s:3:"m a";s:3:"224";s:3:"m s";s:3:"225";s:3:"nod";s:3:"226";s:3:"om ";s:3:"227";s:3:"r a";s:3:"228";s:3:"r i";s:3:"229";s:3:"rk ";s:3:"230";s:3:" fa";s:3:"231";s:3:" si";s:3:"232";s:3:" th";s:3:"233";s:3:"ad ";s:3:"234";s:3:"e m";s:3:"235";s:3:"eac";s:3:"236";s:3:"m m";s:3:"237";s:3:"n w";s:3:"238";s:3:"nob";s:3:"239";s:3:"orl";s:3:"240";s:3:"out";s:3:"241";s:3:"own";s:3:"242";s:3:"r s";s:3:"243";s:3:"r w";s:3:"244";s:3:"rib";s:3:"245";s:3:"rld";s:3:"246";s:3:"s w";s:3:"247";s:3:"ure";s:3:"248";s:3:"wn ";s:3:"249";s:3:" ow";s:3:"250";s:3:"a d";s:3:"251";s:3:"bad";s:3:"252";s:3:"ch ";s:3:"253";s:3:"fre";s:3:"254";s:3:"gs ";s:3:"255";s:3:"m k";s:3:"256";s:3:"nce";s:3:"257";s:3:"ngs";s:3:"258";s:3:"o f";s:3:"259";s:3:"obo";s:3:"260";s:3:"rea";s:3:"261";s:3:"sur";s:3:"262";s:3:"y o";s:3:"263";s:3:" ab";s:3:"264";s:3:" un";s:3:"265";s:3:"abo";s:3:"266";s:3:"ach";s:3:"267";s:3:"bou";s:3:"268";s:3:"d m";s:3:"269";s:3:"dat";s:3:"270";s:3:"e p";s:3:"271";s:3:"g w";s:3:"272";s:3:"hol";s:3:"273";s:3:"i m";s:3:"274";s:3:"i r";s:3:"275";s:3:"m f";s:3:"276";s:3:"m o";s:3:"277";s:3:"n o";s:3:"278";s:3:"now";s:3:"279";s:3:"ry ";s:3:"280";s:3:"s a";s:3:"281";s:3:"t o";s:3:"282";s:3:"tay";s:3:"283";s:3:"wet";s:3:"284";s:3:" ag";s:3:"285";s:3:" bo";s:3:"286";s:3:" da";s:3:"287";s:3:" pr";s:3:"288";s:3:"arr";s:3:"289";s:3:"ati";s:3:"290";s:3:"d d";s:3:"291";s:3:"d p";s:3:"292";s:3:"i g";s:3:"293";s:3:"i t";s:3:"294";s:3:"liv";s:3:"295";s:3:"ly ";s:3:"296";s:3:"n a";s:3:"297";s:3:"od ";s:3:"298";s:3:"ok ";s:3:"299";}s:6:"polish";a:300:{s:3:"ie ";s:1:"0";s:3:"nie";s:1:"1";s:3:"em ";s:1:"2";s:3:" ni";s:1:"3";s:3:" po";s:1:"4";s:3:" pr";s:1:"5";s:3:"dzi";s:1:"6";s:3:" na";s:1:"7";s:4:"że ";s:1:"8";s:3:"rze";s:1:"9";s:3:"na ";s:2:"10";s:4:"łem";s:2:"11";s:3:"wie";s:2:"12";s:3:" w ";s:2:"13";s:4:" że";s:2:"14";s:3:"go ";s:2:"15";s:3:" by";s:2:"16";s:3:"prz";s:2:"17";s:3:"owa";s:2:"18";s:4:"ię ";s:2:"19";s:3:" do";s:2:"20";s:3:" si";s:2:"21";s:3:"owi";s:2:"22";s:3:" pa";s:2:"23";s:3:" za";s:2:"24";s:3:"ch ";s:2:"25";s:3:"ego";s:2:"26";s:4:"ał ";s:2:"27";s:4:"się";s:2:"28";s:3:"ej ";s:2:"29";s:4:"wał";s:2:"30";s:3:"ym ";s:2:"31";s:3:"ani";s:2:"32";s:4:"ałe";s:2:"33";s:3:"to ";s:2:"34";s:3:" i ";s:2:"35";s:3:" to";s:2:"36";s:3:" te";s:2:"37";s:3:"e p";s:2:"38";s:3:" je";s:2:"39";s:3:" z ";s:2:"40";s:3:"czy";s:2:"41";s:4:"był";s:2:"42";s:3:"pan";s:2:"43";s:3:"sta";s:2:"44";s:3:"kie";s:2:"45";s:3:" ja";s:2:"46";s:3:"do ";s:2:"47";s:3:" ch";s:2:"48";s:3:" cz";s:2:"49";s:3:" wi";s:2:"50";s:4:"iał";s:2:"51";s:3:"a p";s:2:"52";s:3:"pow";s:2:"53";s:3:" mi";s:2:"54";s:3:"li ";s:2:"55";s:3:"eni";s:2:"56";s:3:"zie";s:2:"57";s:3:" ta";s:2:"58";s:3:" wa";s:2:"59";s:4:"ło ";s:2:"60";s:4:"ać ";s:2:"61";s:3:"dy ";s:2:"62";s:3:"ak ";s:2:"63";s:3:"e w";s:2:"64";s:3:" a ";s:2:"65";s:3:" od";s:2:"66";s:3:" st";s:2:"67";s:3:"nia";s:2:"68";s:3:"rzy";s:2:"69";s:3:"ied";s:2:"70";s:3:" kt";s:2:"71";s:3:"odz";s:2:"72";s:3:"cie";s:2:"73";s:3:"cze";s:2:"74";s:3:"ia ";s:2:"75";s:3:"iel";s:2:"76";s:4:"któ";s:2:"77";s:3:"o p";s:2:"78";s:4:"tór";s:2:"79";s:4:"ści";s:2:"80";s:3:" sp";s:2:"81";s:3:" wy";s:2:"82";s:3:"jak";s:2:"83";s:3:"tak";s:2:"84";s:3:"zy ";s:2:"85";s:3:" mo";s:2:"86";s:5:"ałę";s:2:"87";s:3:"pro";s:2:"88";s:3:"ski";s:2:"89";s:3:"tem";s:2:"90";s:5:"łęs";s:2:"91";s:3:" tr";s:2:"92";s:3:"e m";s:2:"93";s:3:"jes";s:2:"94";s:3:"my ";s:2:"95";s:3:" ro";s:2:"96";s:3:"edz";s:2:"97";s:3:"eli";s:2:"98";s:3:"iej";s:2:"99";s:3:" rz";s:3:"100";s:3:"a n";s:3:"101";s:3:"ale";s:3:"102";s:3:"an ";s:3:"103";s:3:"e s";s:3:"104";s:3:"est";s:3:"105";s:3:"le ";s:3:"106";s:3:"o s";s:3:"107";s:3:"i p";s:3:"108";s:3:"ki ";s:3:"109";s:3:" co";s:3:"110";s:3:"ada";s:3:"111";s:3:"czn";s:3:"112";s:3:"e t";s:3:"113";s:3:"e z";s:3:"114";s:3:"ent";s:3:"115";s:3:"ny ";s:3:"116";s:3:"pre";s:3:"117";s:4:"rzą";s:3:"118";s:3:"y s";s:3:"119";s:3:" ko";s:3:"120";s:3:" o ";s:3:"121";s:3:"ach";s:3:"122";s:3:"am ";s:3:"123";s:3:"e n";s:3:"124";s:3:"o t";s:3:"125";s:3:"oli";s:3:"126";s:3:"pod";s:3:"127";s:3:"zia";s:3:"128";s:3:" go";s:3:"129";s:3:" ka";s:3:"130";s:3:"by ";s:3:"131";s:3:"ieg";s:3:"132";s:3:"ier";s:3:"133";s:4:"noś";s:3:"134";s:3:"roz";s:3:"135";s:3:"spo";s:3:"136";s:3:"ych";s:3:"137";s:4:"ząd";s:3:"138";s:3:" mn";s:3:"139";s:3:"acz";s:3:"140";s:3:"adz";s:3:"141";s:3:"bie";s:3:"142";s:3:"cho";s:3:"143";s:3:"mni";s:3:"144";s:3:"o n";s:3:"145";s:3:"ost";s:3:"146";s:3:"pra";s:3:"147";s:3:"ze ";s:3:"148";s:4:"ła ";s:3:"149";s:3:" so";s:3:"150";s:3:"a m";s:3:"151";s:3:"cza";s:3:"152";s:3:"iem";s:3:"153";s:4:"ić ";s:3:"154";s:3:"obi";s:3:"155";s:4:"ył ";s:3:"156";s:4:"yło";s:3:"157";s:3:" mu";s:3:"158";s:4:" mó";s:3:"159";s:3:"a t";s:3:"160";s:3:"acj";s:3:"161";s:3:"ci ";s:3:"162";s:3:"e b";s:3:"163";s:3:"ich";s:3:"164";s:3:"kan";s:3:"165";s:3:"mi ";s:3:"166";s:3:"mie";s:3:"167";s:4:"ośc";s:3:"168";s:3:"row";s:3:"169";s:3:"zen";s:3:"170";s:3:"zyd";s:3:"171";s:3:" al";s:3:"172";s:3:" re";s:3:"173";s:3:"a w";s:3:"174";s:3:"den";s:3:"175";s:3:"edy";s:3:"176";s:4:"ił ";s:3:"177";s:3:"ko ";s:3:"178";s:3:"o w";s:3:"179";s:3:"rac";s:3:"180";s:4:"śmy";s:3:"181";s:3:" ma";s:3:"182";s:3:" ra";s:3:"183";s:3:" sz";s:3:"184";s:3:" ty";s:3:"185";s:3:"e j";s:3:"186";s:3:"isk";s:3:"187";s:3:"ji ";s:3:"188";s:3:"ka ";s:3:"189";s:3:"m s";s:3:"190";s:3:"no ";s:3:"191";s:3:"o z";s:3:"192";s:3:"rez";s:3:"193";s:3:"wa ";s:3:"194";s:4:"ów ";s:3:"195";s:4:"łow";s:3:"196";s:5:"ść ";s:3:"197";s:3:" ob";s:3:"198";s:3:"ech";s:3:"199";s:3:"ecz";s:3:"200";s:3:"ezy";s:3:"201";s:3:"i w";s:3:"202";s:3:"ja ";s:3:"203";s:3:"kon";s:3:"204";s:4:"mów";s:3:"205";s:3:"ne ";s:3:"206";s:3:"ni ";s:3:"207";s:3:"now";s:3:"208";s:3:"nym";s:3:"209";s:3:"pol";s:3:"210";s:3:"pot";s:3:"211";s:3:"yde";s:3:"212";s:3:" dl";s:3:"213";s:3:" sy";s:3:"214";s:3:"a s";s:3:"215";s:3:"aki";s:3:"216";s:3:"ali";s:3:"217";s:3:"dla";s:3:"218";s:3:"icz";s:3:"219";s:3:"ku ";s:3:"220";s:3:"ocz";s:3:"221";s:3:"st ";s:3:"222";s:3:"str";s:3:"223";s:3:"szy";s:3:"224";s:3:"trz";s:3:"225";s:3:"wia";s:3:"226";s:3:"y p";s:3:"227";s:3:"za ";s:3:"228";s:3:" wt";s:3:"229";s:3:"chc";s:3:"230";s:3:"esz";s:3:"231";s:3:"iec";s:3:"232";s:3:"im ";s:3:"233";s:3:"la ";s:3:"234";s:3:"o m";s:3:"235";s:3:"sa ";s:3:"236";s:4:"wać";s:3:"237";s:3:"y n";s:3:"238";s:3:"zac";s:3:"239";s:3:"zec";s:3:"240";s:3:" gd";s:3:"241";s:3:"a z";s:3:"242";s:3:"ard";s:3:"243";s:3:"co ";s:3:"244";s:3:"dar";s:3:"245";s:3:"e r";s:3:"246";s:3:"ien";s:3:"247";s:3:"m n";s:3:"248";s:3:"m w";s:3:"249";s:3:"mia";s:3:"250";s:4:"moż";s:3:"251";s:3:"raw";s:3:"252";s:3:"rdz";s:3:"253";s:3:"tan";s:3:"254";s:3:"ted";s:3:"255";s:3:"teg";s:3:"256";s:4:"wił";s:3:"257";s:3:"wte";s:3:"258";s:3:"y z";s:3:"259";s:3:"zna";s:3:"260";s:4:"zło";s:3:"261";s:3:"a r";s:3:"262";s:3:"awi";s:3:"263";s:3:"bar";s:3:"264";s:3:"cji";s:3:"265";s:4:"czą";s:3:"266";s:3:"dow";s:3:"267";s:4:"eż ";s:3:"268";s:3:"gdy";s:3:"269";s:3:"iek";s:3:"270";s:3:"je ";s:3:"271";s:3:"o d";s:3:"272";s:4:"tał";s:3:"273";s:3:"wal";s:3:"274";s:3:"wsz";s:3:"275";s:3:"zed";s:3:"276";s:4:"ówi";s:3:"277";s:4:"ęsa";s:3:"278";s:3:" ba";s:3:"279";s:3:" lu";s:3:"280";s:3:" wo";s:3:"281";s:3:"aln";s:3:"282";s:3:"arn";s:3:"283";s:3:"ba ";s:3:"284";s:3:"dzo";s:3:"285";s:3:"e c";s:3:"286";s:3:"hod";s:3:"287";s:3:"igi";s:3:"288";s:3:"lig";s:3:"289";s:3:"m p";s:3:"290";s:4:"myś";s:3:"291";s:3:"o c";s:3:"292";s:3:"oni";s:3:"293";s:3:"rel";s:3:"294";s:3:"sku";s:3:"295";s:3:"ste";s:3:"296";s:3:"y w";s:3:"297";s:3:"yst";s:3:"298";s:3:"z w";s:3:"299";}s:10:"portuguese";a:300:{s:3:"de ";s:1:"0";s:3:" de";s:1:"1";s:3:"os ";s:1:"2";s:3:"as ";s:1:"3";s:3:"que";s:1:"4";s:3:" co";s:1:"5";s:4:"ão ";s:1:"6";s:3:"o d";s:1:"7";s:3:" qu";s:1:"8";s:3:"ue ";s:1:"9";s:3:" a ";s:2:"10";s:3:"do ";s:2:"11";s:3:"ent";s:2:"12";s:3:" se";s:2:"13";s:3:"a d";s:2:"14";s:3:"s d";s:2:"15";s:3:"e a";s:2:"16";s:3:"es ";s:2:"17";s:3:" pr";s:2:"18";s:3:"ra ";s:2:"19";s:3:"da ";s:2:"20";s:3:" es";s:2:"21";s:3:" pa";s:2:"22";s:3:"to ";s:2:"23";s:3:" o ";s:2:"24";s:3:"em ";s:2:"25";s:3:"con";s:2:"26";s:3:"o p";s:2:"27";s:3:" do";s:2:"28";s:3:"est";s:2:"29";s:3:"nte";s:2:"30";s:5:"ção";s:2:"31";s:3:" da";s:2:"32";s:3:" re";s:2:"33";s:3:"ma ";s:2:"34";s:3:"par";s:2:"35";s:3:" te";s:2:"36";s:3:"ara";s:2:"37";s:3:"ida";s:2:"38";s:3:" e ";s:2:"39";s:3:"ade";s:2:"40";s:3:"is ";s:2:"41";s:3:" um";s:2:"42";s:3:" po";s:2:"43";s:3:"a a";s:2:"44";s:3:"a p";s:2:"45";s:3:"dad";s:2:"46";s:3:"no ";s:2:"47";s:3:"te ";s:2:"48";s:3:" no";s:2:"49";s:5:"açã";s:2:"50";s:3:"pro";s:2:"51";s:3:"al ";s:2:"52";s:3:"com";s:2:"53";s:3:"e d";s:2:"54";s:3:"s a";s:2:"55";s:3:" as";s:2:"56";s:3:"a c";s:2:"57";s:3:"er ";s:2:"58";s:3:"men";s:2:"59";s:3:"s e";s:2:"60";s:3:"ais";s:2:"61";s:3:"nto";s:2:"62";s:3:"res";s:2:"63";s:3:"a s";s:2:"64";s:3:"ado";s:2:"65";s:3:"ist";s:2:"66";s:3:"s p";s:2:"67";s:3:"tem";s:2:"68";s:3:"e c";s:2:"69";s:3:"e s";s:2:"70";s:3:"ia ";s:2:"71";s:3:"o s";s:2:"72";s:3:"o a";s:2:"73";s:3:"o c";s:2:"74";s:3:"e p";s:2:"75";s:3:"sta";s:2:"76";s:3:"ta ";s:2:"77";s:3:"tra";s:2:"78";s:3:"ura";s:2:"79";s:3:" di";s:2:"80";s:3:" pe";s:2:"81";s:3:"ar ";s:2:"82";s:3:"e e";s:2:"83";s:3:"ser";s:2:"84";s:3:"uma";s:2:"85";s:3:"mos";s:2:"86";s:3:"se ";s:2:"87";s:3:" ca";s:2:"88";s:3:"o e";s:2:"89";s:3:" na";s:2:"90";s:3:"a e";s:2:"91";s:3:"des";s:2:"92";s:3:"ont";s:2:"93";s:3:"por";s:2:"94";s:3:" in";s:2:"95";s:3:" ma";s:2:"96";s:3:"ect";s:2:"97";s:3:"o q";s:2:"98";s:3:"ria";s:2:"99";s:3:"s c";s:3:"100";s:3:"ste";s:3:"101";s:3:"ver";s:3:"102";s:3:"cia";s:3:"103";s:3:"dos";s:3:"104";s:3:"ica";s:3:"105";s:3:"str";s:3:"106";s:3:" ao";s:3:"107";s:3:" em";s:3:"108";s:3:"das";s:3:"109";s:3:"e t";s:3:"110";s:3:"ito";s:3:"111";s:3:"iza";s:3:"112";s:3:"pre";s:3:"113";s:3:"tos";s:3:"114";s:4:" nã";s:3:"115";s:3:"ada";s:3:"116";s:4:"não";s:3:"117";s:3:"ess";s:3:"118";s:3:"eve";s:3:"119";s:3:"or ";s:3:"120";s:3:"ran";s:3:"121";s:3:"s n";s:3:"122";s:3:"s t";s:3:"123";s:3:"tur";s:3:"124";s:3:" ac";s:3:"125";s:3:" fa";s:3:"126";s:3:"a r";s:3:"127";s:3:"ens";s:3:"128";s:3:"eri";s:3:"129";s:3:"na ";s:3:"130";s:3:"sso";s:3:"131";s:3:" si";s:3:"132";s:4:" é ";s:3:"133";s:3:"bra";s:3:"134";s:3:"esp";s:3:"135";s:3:"mo ";s:3:"136";s:3:"nos";s:3:"137";s:3:"ro ";s:3:"138";s:3:"um ";s:3:"139";s:3:"a n";s:3:"140";s:3:"ao ";s:3:"141";s:3:"ico";s:3:"142";s:3:"liz";s:3:"143";s:3:"min";s:3:"144";s:3:"o n";s:3:"145";s:3:"ons";s:3:"146";s:3:"pri";s:3:"147";s:3:"ten";s:3:"148";s:3:"tic";s:3:"149";s:4:"ões";s:3:"150";s:3:" tr";s:3:"151";s:3:"a m";s:3:"152";s:3:"aga";s:3:"153";s:3:"e n";s:3:"154";s:3:"ili";s:3:"155";s:3:"ime";s:3:"156";s:3:"m a";s:3:"157";s:3:"nci";s:3:"158";s:3:"nha";s:3:"159";s:3:"nta";s:3:"160";s:3:"spe";s:3:"161";s:3:"tiv";s:3:"162";s:3:"am ";s:3:"163";s:3:"ano";s:3:"164";s:3:"arc";s:3:"165";s:3:"ass";s:3:"166";s:3:"cer";s:3:"167";s:3:"e o";s:3:"168";s:3:"ece";s:3:"169";s:3:"emo";s:3:"170";s:3:"ga ";s:3:"171";s:3:"o m";s:3:"172";s:3:"rag";s:3:"173";s:3:"so ";s:3:"174";s:4:"são";s:3:"175";s:3:" au";s:3:"176";s:3:" os";s:3:"177";s:3:" sa";s:3:"178";s:3:"ali";s:3:"179";s:3:"ca ";s:3:"180";s:3:"ema";s:3:"181";s:3:"emp";s:3:"182";s:3:"ici";s:3:"183";s:3:"ido";s:3:"184";s:3:"inh";s:3:"185";s:3:"iss";s:3:"186";s:3:"l d";s:3:"187";s:3:"la ";s:3:"188";s:3:"lic";s:3:"189";s:3:"m c";s:3:"190";s:3:"mai";s:3:"191";s:3:"onc";s:3:"192";s:3:"pec";s:3:"193";s:3:"ram";s:3:"194";s:3:"s q";s:3:"195";s:3:" ci";s:3:"196";s:3:" en";s:3:"197";s:3:" fo";s:3:"198";s:3:"a o";s:3:"199";s:3:"ame";s:3:"200";s:3:"car";s:3:"201";s:3:"co ";s:3:"202";s:3:"der";s:3:"203";s:3:"eir";s:3:"204";s:3:"ho ";s:3:"205";s:3:"io ";s:3:"206";s:3:"om ";s:3:"207";s:3:"ora";s:3:"208";s:3:"r a";s:3:"209";s:3:"sen";s:3:"210";s:3:"ter";s:3:"211";s:3:" br";s:3:"212";s:3:" ex";s:3:"213";s:3:"a u";s:3:"214";s:3:"cul";s:3:"215";s:3:"dev";s:3:"216";s:3:"e u";s:3:"217";s:3:"ha ";s:3:"218";s:3:"mpr";s:3:"219";s:3:"nce";s:3:"220";s:3:"oca";s:3:"221";s:3:"ove";s:3:"222";s:3:"rio";s:3:"223";s:3:"s o";s:3:"224";s:3:"sa ";s:3:"225";s:3:"sem";s:3:"226";s:3:"tes";s:3:"227";s:3:"uni";s:3:"228";s:3:"ven";s:3:"229";s:4:"zaç";s:3:"230";s:5:"çõe";s:3:"231";s:3:" ad";s:3:"232";s:3:" al";s:3:"233";s:3:" an";s:3:"234";s:3:" mi";s:3:"235";s:3:" mo";s:3:"236";s:3:" ve";s:3:"237";s:4:" à ";s:3:"238";s:3:"a i";s:3:"239";s:3:"a q";s:3:"240";s:3:"ala";s:3:"241";s:3:"amo";s:3:"242";s:3:"bli";s:3:"243";s:3:"cen";s:3:"244";s:3:"col";s:3:"245";s:3:"cos";s:3:"246";s:3:"cto";s:3:"247";s:3:"e m";s:3:"248";s:3:"e v";s:3:"249";s:3:"ede";s:3:"250";s:4:"gás";s:3:"251";s:3:"ias";s:3:"252";s:3:"ita";s:3:"253";s:3:"iva";s:3:"254";s:3:"ndo";s:3:"255";s:3:"o t";s:3:"256";s:3:"ore";s:3:"257";s:3:"r d";s:3:"258";s:3:"ral";s:3:"259";s:3:"rea";s:3:"260";s:3:"s f";s:3:"261";s:3:"sid";s:3:"262";s:3:"tro";s:3:"263";s:3:"vel";s:3:"264";s:3:"vid";s:3:"265";s:4:"ás ";s:3:"266";s:3:" ap";s:3:"267";s:3:" ar";s:3:"268";s:3:" ce";s:3:"269";s:3:" ou";s:3:"270";s:4:" pú";s:3:"271";s:3:" so";s:3:"272";s:3:" vi";s:3:"273";s:3:"a f";s:3:"274";s:3:"act";s:3:"275";s:3:"arr";s:3:"276";s:3:"bil";s:3:"277";s:3:"cam";s:3:"278";s:3:"e f";s:3:"279";s:3:"e i";s:3:"280";s:3:"el ";s:3:"281";s:3:"for";s:3:"282";s:3:"lem";s:3:"283";s:3:"lid";s:3:"284";s:3:"lo ";s:3:"285";s:3:"m d";s:3:"286";s:3:"mar";s:3:"287";s:3:"nde";s:3:"288";s:3:"o o";s:3:"289";s:3:"omo";s:3:"290";s:3:"ort";s:3:"291";s:3:"per";s:3:"292";s:4:"púb";s:3:"293";s:3:"r u";s:3:"294";s:3:"rei";s:3:"295";s:3:"rem";s:3:"296";s:3:"ros";s:3:"297";s:3:"rre";s:3:"298";s:3:"ssi";s:3:"299";}s:8:"romanian";a:300:{s:3:" de";s:1:"0";s:4:" în";s:1:"1";s:3:"de ";s:1:"2";s:3:" a ";s:1:"3";s:3:"ul ";s:1:"4";s:3:" co";s:1:"5";s:4:"în ";s:1:"6";s:3:"re ";s:1:"7";s:3:"e d";s:1:"8";s:3:"ea ";s:1:"9";s:3:" di";s:2:"10";s:3:" pr";s:2:"11";s:3:"le ";s:2:"12";s:4:"şi ";s:2:"13";s:3:"are";s:2:"14";s:3:"at ";s:2:"15";s:3:"con";s:2:"16";s:3:"ui ";s:2:"17";s:4:" şi";s:2:"18";s:3:"i d";s:2:"19";s:3:"ii ";s:2:"20";s:3:" cu";s:2:"21";s:3:"e a";s:2:"22";s:3:"lui";s:2:"23";s:3:"ern";s:2:"24";s:3:"te ";s:2:"25";s:3:"cu ";s:2:"26";s:3:" la";s:2:"27";s:3:"a c";s:2:"28";s:4:"că ";s:2:"29";s:3:"din";s:2:"30";s:3:"e c";s:2:"31";s:3:"or ";s:2:"32";s:3:"ulu";s:2:"33";s:3:"ne ";s:2:"34";s:3:"ter";s:2:"35";s:3:"la ";s:2:"36";s:4:"să ";s:2:"37";s:3:"tat";s:2:"38";s:3:"tre";s:2:"39";s:3:" ac";s:2:"40";s:4:" să";s:2:"41";s:3:"est";s:2:"42";s:3:"st ";s:2:"43";s:4:"tă ";s:2:"44";s:3:" ca";s:2:"45";s:3:" ma";s:2:"46";s:3:" pe";s:2:"47";s:3:"cur";s:2:"48";s:3:"ist";s:2:"49";s:4:"mân";s:2:"50";s:3:"a d";s:2:"51";s:3:"i c";s:2:"52";s:3:"nat";s:2:"53";s:3:" ce";s:2:"54";s:3:"i a";s:2:"55";s:3:"ia ";s:2:"56";s:3:"in ";s:2:"57";s:3:"scu";s:2:"58";s:3:" mi";s:2:"59";s:3:"ato";s:2:"60";s:4:"aţi";s:2:"61";s:3:"ie ";s:2:"62";s:3:" re";s:2:"63";s:3:" se";s:2:"64";s:3:"a a";s:2:"65";s:3:"int";s:2:"66";s:3:"ntr";s:2:"67";s:3:"tru";s:2:"68";s:3:"uri";s:2:"69";s:4:"ă a";s:2:"70";s:3:" fo";s:2:"71";s:3:" pa";s:2:"72";s:3:"ate";s:2:"73";s:3:"ini";s:2:"74";s:3:"tul";s:2:"75";s:3:"ent";s:2:"76";s:3:"min";s:2:"77";s:3:"pre";s:2:"78";s:3:"pro";s:2:"79";s:3:"a p";s:2:"80";s:3:"e p";s:2:"81";s:3:"e s";s:2:"82";s:3:"ei ";s:2:"83";s:4:"nă ";s:2:"84";s:3:"par";s:2:"85";s:3:"rna";s:2:"86";s:3:"rul";s:2:"87";s:3:"tor";s:2:"88";s:3:" in";s:2:"89";s:3:" ro";s:2:"90";s:3:" tr";s:2:"91";s:3:" un";s:2:"92";s:3:"al ";s:2:"93";s:3:"ale";s:2:"94";s:3:"art";s:2:"95";s:3:"ce ";s:2:"96";s:3:"e e";s:2:"97";s:4:"e î";s:2:"98";s:3:"fos";s:2:"99";s:3:"ita";s:3:"100";s:3:"nte";s:3:"101";s:4:"omâ";s:3:"102";s:3:"ost";s:3:"103";s:3:"rom";s:3:"104";s:3:"ru ";s:3:"105";s:3:"str";s:3:"106";s:3:"ver";s:3:"107";s:3:" ex";s:3:"108";s:3:" na";s:3:"109";s:3:"a f";s:3:"110";s:3:"lor";s:3:"111";s:3:"nis";s:3:"112";s:3:"rea";s:3:"113";s:3:"rit";s:3:"114";s:3:" al";s:3:"115";s:3:" eu";s:3:"116";s:3:" no";s:3:"117";s:3:"ace";s:3:"118";s:3:"cer";s:3:"119";s:3:"ile";s:3:"120";s:3:"nal";s:3:"121";s:3:"pri";s:3:"122";s:3:"ri ";s:3:"123";s:3:"sta";s:3:"124";s:3:"ste";s:3:"125";s:4:"ţie";s:3:"126";s:3:" au";s:3:"127";s:3:" da";s:3:"128";s:3:" ju";s:3:"129";s:3:" po";s:3:"130";s:3:"ar ";s:3:"131";s:3:"au ";s:3:"132";s:3:"ele";s:3:"133";s:3:"ere";s:3:"134";s:3:"eri";s:3:"135";s:3:"ina";s:3:"136";s:3:"n a";s:3:"137";s:3:"n c";s:3:"138";s:3:"res";s:3:"139";s:3:"se ";s:3:"140";s:3:"t a";s:3:"141";s:3:"tea";s:3:"142";s:4:" că";s:3:"143";s:3:" do";s:3:"144";s:3:" fi";s:3:"145";s:3:"a s";s:3:"146";s:4:"ată";s:3:"147";s:3:"com";s:3:"148";s:4:"e ş";s:3:"149";s:3:"eur";s:3:"150";s:3:"guv";s:3:"151";s:3:"i s";s:3:"152";s:3:"ice";s:3:"153";s:3:"ili";s:3:"154";s:3:"na ";s:3:"155";s:3:"rec";s:3:"156";s:3:"rep";s:3:"157";s:3:"ril";s:3:"158";s:3:"rne";s:3:"159";s:3:"rti";s:3:"160";s:3:"uro";s:3:"161";s:3:"uve";s:3:"162";s:4:"ă p";s:3:"163";s:3:" ar";s:3:"164";s:3:" o ";s:3:"165";s:3:" su";s:3:"166";s:3:" vi";s:3:"167";s:3:"dec";s:3:"168";s:3:"dre";s:3:"169";s:3:"oar";s:3:"170";s:3:"ons";s:3:"171";s:3:"pe ";s:3:"172";s:3:"rii";s:3:"173";s:3:" ad";s:3:"174";s:3:" ge";s:3:"175";s:3:"a m";s:3:"176";s:3:"a r";s:3:"177";s:3:"ain";s:3:"178";s:3:"ali";s:3:"179";s:3:"car";s:3:"180";s:3:"cat";s:3:"181";s:3:"ecu";s:3:"182";s:3:"ene";s:3:"183";s:3:"ept";s:3:"184";s:3:"ext";s:3:"185";s:3:"ilo";s:3:"186";s:3:"iu ";s:3:"187";s:3:"n p";s:3:"188";s:3:"ori";s:3:"189";s:3:"sec";s:3:"190";s:3:"u p";s:3:"191";s:3:"une";s:3:"192";s:4:"ă c";s:3:"193";s:4:"şti";s:3:"194";s:4:"ţia";s:3:"195";s:3:" ch";s:3:"196";s:3:" gu";s:3:"197";s:3:"ai ";s:3:"198";s:3:"ani";s:3:"199";s:3:"cea";s:3:"200";s:3:"e f";s:3:"201";s:3:"isc";s:3:"202";s:3:"l a";s:3:"203";s:3:"lic";s:3:"204";s:3:"liu";s:3:"205";s:3:"mar";s:3:"206";s:3:"nic";s:3:"207";s:3:"nt ";s:3:"208";s:3:"nul";s:3:"209";s:3:"ris";s:3:"210";s:3:"t c";s:3:"211";s:3:"t p";s:3:"212";s:3:"tic";s:3:"213";s:3:"tid";s:3:"214";s:3:"u a";s:3:"215";s:3:"ucr";s:3:"216";s:3:" as";s:3:"217";s:3:" dr";s:3:"218";s:3:" fa";s:3:"219";s:3:" nu";s:3:"220";s:3:" pu";s:3:"221";s:3:" to";s:3:"222";s:3:"cra";s:3:"223";s:3:"dis";s:3:"224";s:4:"enţ";s:3:"225";s:3:"esc";s:3:"226";s:3:"gen";s:3:"227";s:3:"it ";s:3:"228";s:3:"ivi";s:3:"229";s:3:"l d";s:3:"230";s:3:"n d";s:3:"231";s:3:"nd ";s:3:"232";s:3:"nu ";s:3:"233";s:3:"ond";s:3:"234";s:3:"pen";s:3:"235";s:3:"ral";s:3:"236";s:3:"riv";s:3:"237";s:3:"rte";s:3:"238";s:3:"sti";s:3:"239";s:3:"t d";s:3:"240";s:3:"ta ";s:3:"241";s:3:"to ";s:3:"242";s:3:"uni";s:3:"243";s:3:"xte";s:3:"244";s:4:"ând";s:3:"245";s:4:"îns";s:3:"246";s:4:"ă s";s:3:"247";s:3:" bl";s:3:"248";s:3:" st";s:3:"249";s:3:" uc";s:3:"250";s:3:"a b";s:3:"251";s:3:"a i";s:3:"252";s:3:"a l";s:3:"253";s:3:"air";s:3:"254";s:3:"ast";s:3:"255";s:3:"bla";s:3:"256";s:3:"bri";s:3:"257";s:3:"che";s:3:"258";s:3:"duc";s:3:"259";s:3:"dul";s:3:"260";s:3:"e m";s:3:"261";s:3:"eas";s:3:"262";s:3:"edi";s:3:"263";s:3:"esp";s:3:"264";s:3:"i l";s:3:"265";s:3:"i p";s:3:"266";s:3:"ica";s:3:"267";s:4:"ică";s:3:"268";s:3:"ir ";s:3:"269";s:3:"iun";s:3:"270";s:3:"jud";s:3:"271";s:3:"lai";s:3:"272";s:3:"lul";s:3:"273";s:3:"mai";s:3:"274";s:3:"men";s:3:"275";s:3:"ni ";s:3:"276";s:3:"pus";s:3:"277";s:3:"put";s:3:"278";s:3:"ra ";s:3:"279";s:3:"rai";s:3:"280";s:3:"rop";s:3:"281";s:3:"sil";s:3:"282";s:3:"ti ";s:3:"283";s:3:"tra";s:3:"284";s:3:"u s";s:3:"285";s:3:"ua ";s:3:"286";s:3:"ude";s:3:"287";s:3:"urs";s:3:"288";s:4:"ân ";s:3:"289";s:4:"înt";s:3:"290";s:5:"ţă ";s:3:"291";s:3:" lu";s:3:"292";s:3:" mo";s:3:"293";s:3:" s ";s:3:"294";s:3:" sa";s:3:"295";s:3:" sc";s:3:"296";s:3:"a u";s:3:"297";s:3:"an ";s:3:"298";s:3:"atu";s:3:"299";}s:7:"russian";a:300:{s:5:" на";s:1:"0";s:5:" пр";s:1:"1";s:5:"то ";s:1:"2";s:5:" не";s:1:"3";s:5:"ли ";s:1:"4";s:5:" по";s:1:"5";s:5:"но ";s:1:"6";s:4:" в ";s:1:"7";s:5:"на ";s:1:"8";s:5:"ть ";s:1:"9";s:5:"не ";s:2:"10";s:4:" и ";s:2:"11";s:5:" ко";s:2:"12";s:5:"ом ";s:2:"13";s:6:"про";s:2:"14";s:5:" то";s:2:"15";s:5:"их ";s:2:"16";s:5:" ка";s:2:"17";s:6:"ать";s:2:"18";s:6:"ото";s:2:"19";s:5:" за";s:2:"20";s:5:"ие ";s:2:"21";s:6:"ова";s:2:"22";s:6:"тел";s:2:"23";s:6:"тор";s:2:"24";s:5:" де";s:2:"25";s:5:"ой ";s:2:"26";s:6:"сти";s:2:"27";s:5:" от";s:2:"28";s:5:"ах ";s:2:"29";s:5:"ми ";s:2:"30";s:6:"стр";s:2:"31";s:5:" бе";s:2:"32";s:5:" во";s:2:"33";s:5:" ра";s:2:"34";s:5:"ая ";s:2:"35";s:6:"ват";s:2:"36";s:5:"ей ";s:2:"37";s:5:"ет ";s:2:"38";s:5:"же ";s:2:"39";s:6:"иче";s:2:"40";s:5:"ия ";s:2:"41";s:5:"ов ";s:2:"42";s:6:"сто";s:2:"43";s:5:" об";s:2:"44";s:6:"вер";s:2:"45";s:5:"го ";s:2:"46";s:5:"и в";s:2:"47";s:5:"и п";s:2:"48";s:5:"и с";s:2:"49";s:5:"ии ";s:2:"50";s:6:"ист";s:2:"51";s:5:"о в";s:2:"52";s:6:"ост";s:2:"53";s:6:"тра";s:2:"54";s:5:" те";s:2:"55";s:6:"ели";s:2:"56";s:6:"ере";s:2:"57";s:6:"кот";s:2:"58";s:6:"льн";s:2:"59";s:6:"ник";s:2:"60";s:6:"нти";s:2:"61";s:5:"о с";s:2:"62";s:6:"рор";s:2:"63";s:6:"ств";s:2:"64";s:6:"чес";s:2:"65";s:5:" бо";s:2:"66";s:5:" ве";s:2:"67";s:5:" да";s:2:"68";s:5:" ин";s:2:"69";s:5:" но";s:2:"70";s:4:" с ";s:2:"71";s:5:" со";s:2:"72";s:5:" сп";s:2:"73";s:5:" ст";s:2:"74";s:5:" чт";s:2:"75";s:6:"али";s:2:"76";s:6:"ами";s:2:"77";s:6:"вид";s:2:"78";s:6:"дет";s:2:"79";s:5:"е н";s:2:"80";s:6:"ель";s:2:"81";s:6:"еск";s:2:"82";s:6:"ест";s:2:"83";s:6:"зал";s:2:"84";s:5:"и н";s:2:"85";s:6:"ива";s:2:"86";s:6:"кон";s:2:"87";s:6:"ого";s:2:"88";s:6:"одн";s:2:"89";s:6:"ожн";s:2:"90";s:6:"оль";s:2:"91";s:6:"ори";s:2:"92";s:6:"ров";s:2:"93";s:6:"ско";s:2:"94";s:5:"ся ";s:2:"95";s:6:"тер";s:2:"96";s:6:"что";s:2:"97";s:5:" мо";s:2:"98";s:5:" са";s:2:"99";s:5:" эт";s:3:"100";s:6:"ант";s:3:"101";s:6:"все";s:3:"102";s:6:"ерр";s:3:"103";s:6:"есл";s:3:"104";s:6:"иде";s:3:"105";s:6:"ина";s:3:"106";s:6:"ино";s:3:"107";s:6:"иро";s:3:"108";s:6:"ите";s:3:"109";s:5:"ка ";s:3:"110";s:5:"ко ";s:3:"111";s:6:"кол";s:3:"112";s:6:"ком";s:3:"113";s:5:"ла ";s:3:"114";s:6:"ния";s:3:"115";s:5:"о т";s:3:"116";s:6:"оло";s:3:"117";s:6:"ран";s:3:"118";s:6:"ред";s:3:"119";s:5:"сь ";s:3:"120";s:6:"тив";s:3:"121";s:6:"тич";s:3:"122";s:5:"ых ";s:3:"123";s:5:" ви";s:3:"124";s:5:" вс";s:3:"125";s:5:" го";s:3:"126";s:5:" ма";s:3:"127";s:5:" сл";s:3:"128";s:6:"ако";s:3:"129";s:6:"ани";s:3:"130";s:6:"аст";s:3:"131";s:6:"без";s:3:"132";s:6:"дел";s:3:"133";s:5:"е д";s:3:"134";s:5:"е п";s:3:"135";s:5:"ем ";s:3:"136";s:6:"жно";s:3:"137";s:5:"и д";s:3:"138";s:6:"ика";s:3:"139";s:6:"каз";s:3:"140";s:6:"как";s:3:"141";s:5:"ки ";s:3:"142";s:6:"нос";s:3:"143";s:5:"о н";s:3:"144";s:6:"опа";s:3:"145";s:6:"при";s:3:"146";s:6:"рро";s:3:"147";s:6:"ски";s:3:"148";s:5:"ти ";s:3:"149";s:6:"тов";s:3:"150";s:5:"ые ";s:3:"151";s:5:" вы";s:3:"152";s:5:" до";s:3:"153";s:5:" ме";s:3:"154";s:5:" ни";s:3:"155";s:5:" од";s:3:"156";s:5:" ро";s:3:"157";s:5:" св";s:3:"158";s:5:" чи";s:3:"159";s:5:"а н";s:3:"160";s:6:"ает";s:3:"161";s:6:"аза";s:3:"162";s:6:"ате";s:3:"163";s:6:"бес";s:3:"164";s:5:"в п";s:3:"165";s:5:"ва ";s:3:"166";s:5:"е в";s:3:"167";s:5:"е м";s:3:"168";s:5:"е с";s:3:"169";s:5:"ез ";s:3:"170";s:6:"ени";s:3:"171";s:5:"за ";s:3:"172";s:6:"зна";s:3:"173";s:6:"ини";s:3:"174";s:6:"кам";s:3:"175";s:6:"ках";s:3:"176";s:6:"кто";s:3:"177";s:6:"лов";s:3:"178";s:6:"мер";s:3:"179";s:6:"мож";s:3:"180";s:6:"нал";s:3:"181";s:6:"ниц";s:3:"182";s:5:"ны ";s:3:"183";s:6:"ным";s:3:"184";s:6:"ора";s:3:"185";s:6:"оро";s:3:"186";s:5:"от ";s:3:"187";s:6:"пор";s:3:"188";s:6:"рав";s:3:"189";s:6:"рес";s:3:"190";s:6:"рис";s:3:"191";s:6:"рос";s:3:"192";s:6:"ска";s:3:"193";s:5:"т н";s:3:"194";s:6:"том";s:3:"195";s:6:"чит";s:3:"196";s:6:"шко";s:3:"197";s:5:" бы";s:3:"198";s:4:" о ";s:3:"199";s:5:" тр";s:3:"200";s:5:" уж";s:3:"201";s:5:" чу";s:3:"202";s:5:" шк";s:3:"203";s:5:"а б";s:3:"204";s:5:"а в";s:3:"205";s:5:"а р";s:3:"206";s:6:"аби";s:3:"207";s:6:"ала";s:3:"208";s:6:"ало";s:3:"209";s:6:"аль";s:3:"210";s:6:"анн";s:3:"211";s:6:"ати";s:3:"212";s:6:"бин";s:3:"213";s:6:"вес";s:3:"214";s:6:"вно";s:3:"215";s:5:"во ";s:3:"216";s:6:"вши";s:3:"217";s:6:"дал";s:3:"218";s:6:"дат";s:3:"219";s:6:"дно";s:3:"220";s:5:"е з";s:3:"221";s:6:"его";s:3:"222";s:6:"еле";s:3:"223";s:6:"енн";s:3:"224";s:6:"ент";s:3:"225";s:6:"ете";s:3:"226";s:5:"и о";s:3:"227";s:6:"или";s:3:"228";s:6:"ись";s:3:"229";s:5:"ит ";s:3:"230";s:6:"ици";s:3:"231";s:6:"ков";s:3:"232";s:6:"лен";s:3:"233";s:6:"льк";s:3:"234";s:6:"мен";s:3:"235";s:5:"мы ";s:3:"236";s:6:"нет";s:3:"237";s:5:"ни ";s:3:"238";s:6:"нны";s:3:"239";s:6:"ног";s:3:"240";s:6:"ной";s:3:"241";s:6:"ном";s:3:"242";s:5:"о п";s:3:"243";s:6:"обн";s:3:"244";s:6:"ове";s:3:"245";s:6:"овн";s:3:"246";s:6:"оры";s:3:"247";s:6:"пер";s:3:"248";s:5:"по ";s:3:"249";s:6:"пра";s:3:"250";s:6:"пре";s:3:"251";s:6:"раз";s:3:"252";s:6:"роп";s:3:"253";s:5:"ры ";s:3:"254";s:5:"се ";s:3:"255";s:6:"сли";s:3:"256";s:6:"сов";s:3:"257";s:6:"тре";s:3:"258";s:6:"тся";s:3:"259";s:6:"уро";s:3:"260";s:6:"цел";s:3:"261";s:6:"чно";s:3:"262";s:5:"ь в";s:3:"263";s:6:"ько";s:3:"264";s:6:"ьно";s:3:"265";s:6:"это";s:3:"266";s:5:"ют ";s:3:"267";s:5:"я н";s:3:"268";s:5:" ан";s:3:"269";s:5:" ес";s:3:"270";s:5:" же";s:3:"271";s:5:" из";s:3:"272";s:5:" кт";s:3:"273";s:5:" ми";s:3:"274";s:5:" мы";s:3:"275";s:5:" пе";s:3:"276";s:5:" се";s:3:"277";s:5:" це";s:3:"278";s:5:"а м";s:3:"279";s:5:"а п";s:3:"280";s:5:"а т";s:3:"281";s:6:"авш";s:3:"282";s:6:"аже";s:3:"283";s:5:"ак ";s:3:"284";s:5:"ал ";s:3:"285";s:6:"але";s:3:"286";s:6:"ане";s:3:"287";s:6:"ачи";s:3:"288";s:6:"ают";s:3:"289";s:6:"бна";s:3:"290";s:6:"бол";s:3:"291";s:5:"бы ";s:3:"292";s:5:"в и";s:3:"293";s:5:"в с";s:3:"294";s:6:"ван";s:3:"295";s:6:"гра";s:3:"296";s:6:"даж";s:3:"297";s:6:"ден";s:3:"298";s:5:"е к";s:3:"299";}s:7:"serbian";a:300:{s:5:" на";s:1:"0";s:5:" је";s:1:"1";s:5:" по";s:1:"2";s:5:"је ";s:1:"3";s:4:" и ";s:1:"4";s:5:" не";s:1:"5";s:5:" пр";s:1:"6";s:5:"га ";s:1:"7";s:5:" св";s:1:"8";s:5:"ог ";s:1:"9";s:5:"а с";s:2:"10";s:5:"их ";s:2:"11";s:5:"на ";s:2:"12";s:6:"кој";s:2:"13";s:6:"ога";s:2:"14";s:4:" у ";s:2:"15";s:5:"а п";s:2:"16";s:5:"не ";s:2:"17";s:5:"ни ";s:2:"18";s:5:"ти ";s:2:"19";s:5:" да";s:2:"20";s:5:"ом ";s:2:"21";s:5:" ве";s:2:"22";s:5:" ср";s:2:"23";s:5:"и с";s:2:"24";s:6:"ско";s:2:"25";s:5:" об";s:2:"26";s:5:"а н";s:2:"27";s:5:"да ";s:2:"28";s:5:"е н";s:2:"29";s:5:"но ";s:2:"30";s:6:"ног";s:2:"31";s:5:"о ј";s:2:"32";s:5:"ој ";s:2:"33";s:5:" за";s:2:"34";s:5:"ва ";s:2:"35";s:5:"е с";s:2:"36";s:5:"и п";s:2:"37";s:5:"ма ";s:2:"38";s:6:"ник";s:2:"39";s:6:"обр";s:2:"40";s:6:"ова";s:2:"41";s:5:" ко";s:2:"42";s:5:"а и";s:2:"43";s:6:"диј";s:2:"44";s:5:"е п";s:2:"45";s:5:"ка ";s:2:"46";s:5:"ко ";s:2:"47";s:6:"ког";s:2:"48";s:6:"ост";s:2:"49";s:6:"све";s:2:"50";s:6:"ств";s:2:"51";s:6:"сти";s:2:"52";s:6:"тра";s:2:"53";s:6:"еди";s:2:"54";s:6:"има";s:2:"55";s:6:"пок";s:2:"56";s:6:"пра";s:2:"57";s:6:"раз";s:2:"58";s:5:"те ";s:2:"59";s:5:" бо";s:2:"60";s:5:" ви";s:2:"61";s:5:" са";s:2:"62";s:6:"аво";s:2:"63";s:6:"бра";s:2:"64";s:6:"гос";s:2:"65";s:5:"е и";s:2:"66";s:6:"ели";s:2:"67";s:6:"ени";s:2:"68";s:5:"за ";s:2:"69";s:6:"ики";s:2:"70";s:5:"ио ";s:2:"71";s:6:"пре";s:2:"72";s:6:"рав";s:2:"73";s:6:"рад";s:2:"74";s:5:"у с";s:2:"75";s:5:"ју ";s:2:"76";s:5:"ња ";s:2:"77";s:5:" би";s:2:"78";s:5:" до";s:2:"79";s:5:" ст";s:2:"80";s:6:"аст";s:2:"81";s:6:"бој";s:2:"82";s:6:"ебо";s:2:"83";s:5:"и н";s:2:"84";s:5:"им ";s:2:"85";s:5:"ку ";s:2:"86";s:6:"лан";s:2:"87";s:6:"неб";s:2:"88";s:6:"ово";s:2:"89";s:6:"ого";s:2:"90";s:6:"осл";s:2:"91";s:6:"ојш";s:2:"92";s:6:"пед";s:2:"93";s:6:"стр";s:2:"94";s:6:"час";s:2:"95";s:5:" го";s:2:"96";s:5:" кр";s:2:"97";s:5:" мо";s:2:"98";s:5:" чл";s:2:"99";s:5:"а м";s:3:"100";s:5:"а о";s:3:"101";s:6:"ако";s:3:"102";s:6:"ача";s:3:"103";s:6:"вел";s:3:"104";s:6:"вет";s:3:"105";s:6:"вог";s:3:"106";s:6:"еда";s:3:"107";s:6:"ист";s:3:"108";s:6:"ити";s:3:"109";s:6:"ије";s:3:"110";s:6:"око";s:3:"111";s:6:"сло";s:3:"112";s:6:"срб";s:3:"113";s:6:"чла";s:3:"114";s:5:" бе";s:3:"115";s:5:" ос";s:3:"116";s:5:" от";s:3:"117";s:5:" ре";s:3:"118";s:5:" се";s:3:"119";s:5:"а в";s:3:"120";s:5:"ан ";s:3:"121";s:6:"бог";s:3:"122";s:6:"бро";s:3:"123";s:6:"вен";s:3:"124";s:6:"гра";s:3:"125";s:5:"е о";s:3:"126";s:6:"ика";s:3:"127";s:6:"ија";s:3:"128";s:6:"ких";s:3:"129";s:6:"ком";s:3:"130";s:5:"ли ";s:3:"131";s:5:"ну ";s:3:"132";s:6:"ота";s:3:"133";s:6:"ојн";s:3:"134";s:6:"под";s:3:"135";s:6:"рбс";s:3:"136";s:6:"ред";s:3:"137";s:6:"рој";s:3:"138";s:5:"са ";s:3:"139";s:6:"сни";s:3:"140";s:6:"тач";s:3:"141";s:6:"тва";s:3:"142";s:5:"ја ";s:3:"143";s:5:"ји ";s:3:"144";s:5:" ка";s:3:"145";s:5:" ов";s:3:"146";s:5:" тр";s:3:"147";s:5:"а ј";s:3:"148";s:6:"ави";s:3:"149";s:5:"аз ";s:3:"150";s:6:"ано";s:3:"151";s:6:"био";s:3:"152";s:6:"вик";s:3:"153";s:5:"во ";s:3:"154";s:6:"гов";s:3:"155";s:6:"дни";s:3:"156";s:5:"е ч";s:3:"157";s:6:"его";s:3:"158";s:5:"и о";s:3:"159";s:6:"ива";s:3:"160";s:6:"иво";s:3:"161";s:5:"ик ";s:3:"162";s:6:"ине";s:3:"163";s:6:"ини";s:3:"164";s:6:"ипе";s:3:"165";s:6:"кип";s:3:"166";s:6:"лик";s:3:"167";s:5:"ло ";s:3:"168";s:6:"наш";s:3:"169";s:6:"нос";s:3:"170";s:5:"о т";s:3:"171";s:5:"од ";s:3:"172";s:6:"оди";s:3:"173";s:6:"она";s:3:"174";s:6:"оји";s:3:"175";s:6:"поч";s:3:"176";s:6:"про";s:3:"177";s:5:"ра ";s:3:"178";s:6:"рис";s:3:"179";s:6:"род";s:3:"180";s:6:"рст";s:3:"181";s:5:"се ";s:3:"182";s:6:"спо";s:3:"183";s:6:"ста";s:3:"184";s:6:"тић";s:3:"185";s:5:"у д";s:3:"186";s:5:"у н";s:3:"187";s:5:"у о";s:3:"188";s:6:"чин";s:3:"189";s:5:"ша ";s:3:"190";s:6:"јед";s:3:"191";s:6:"јни";s:3:"192";s:5:"ће ";s:3:"193";s:4:" м ";s:3:"194";s:5:" ме";s:3:"195";s:5:" ни";s:3:"196";s:5:" он";s:3:"197";s:5:" па";s:3:"198";s:5:" сл";s:3:"199";s:5:" те";s:3:"200";s:5:"а у";s:3:"201";s:6:"ава";s:3:"202";s:6:"аве";s:3:"203";s:6:"авн";s:3:"204";s:6:"ана";s:3:"205";s:5:"ао ";s:3:"206";s:6:"ати";s:3:"207";s:6:"аци";s:3:"208";s:6:"ају";s:3:"209";s:6:"ања";s:3:"210";s:6:"бск";s:3:"211";s:6:"вор";s:3:"212";s:6:"вос";s:3:"213";s:6:"вск";s:3:"214";s:6:"дин";s:3:"215";s:5:"е у";s:3:"216";s:6:"едн";s:3:"217";s:6:"ези";s:3:"218";s:6:"ека";s:3:"219";s:6:"ено";s:3:"220";s:6:"ето";s:3:"221";s:6:"ења";s:3:"222";s:6:"жив";s:3:"223";s:5:"и г";s:3:"224";s:5:"и и";s:3:"225";s:5:"и к";s:3:"226";s:5:"и т";s:3:"227";s:6:"ику";s:3:"228";s:6:"ичк";s:3:"229";s:5:"ки ";s:3:"230";s:6:"крс";s:3:"231";s:5:"ла ";s:3:"232";s:6:"лав";s:3:"233";s:6:"лит";s:3:"234";s:5:"ме ";s:3:"235";s:6:"мен";s:3:"236";s:6:"нац";s:3:"237";s:5:"о н";s:3:"238";s:5:"о п";s:3:"239";s:5:"о у";s:3:"240";s:6:"одн";s:3:"241";s:6:"оли";s:3:"242";s:6:"орн";s:3:"243";s:6:"осн";s:3:"244";s:6:"осп";s:3:"245";s:6:"оче";s:3:"246";s:6:"пск";s:3:"247";s:6:"реч";s:3:"248";s:6:"рпс";s:3:"249";s:6:"сво";s:3:"250";s:6:"ски";s:3:"251";s:6:"сла";s:3:"252";s:6:"срп";s:3:"253";s:5:"су ";s:3:"254";s:5:"та ";s:3:"255";s:6:"тав";s:3:"256";s:6:"тве";s:3:"257";s:5:"у б";s:3:"258";s:6:"јез";s:3:"259";s:5:"ћи ";s:3:"260";s:5:" ен";s:3:"261";s:5:" жи";s:3:"262";s:5:" им";s:3:"263";s:5:" му";s:3:"264";s:5:" од";s:3:"265";s:5:" су";s:3:"266";s:5:" та";s:3:"267";s:5:" хр";s:3:"268";s:5:" ча";s:3:"269";s:5:" шт";s:3:"270";s:5:" ње";s:3:"271";s:5:"а д";s:3:"272";s:5:"а з";s:3:"273";s:5:"а к";s:3:"274";s:5:"а т";s:3:"275";s:6:"аду";s:3:"276";s:6:"ало";s:3:"277";s:6:"ани";s:3:"278";s:6:"асо";s:3:"279";s:6:"ван";s:3:"280";s:6:"вач";s:3:"281";s:6:"вањ";s:3:"282";s:6:"вед";s:3:"283";s:5:"ви ";s:3:"284";s:6:"вно";s:3:"285";s:6:"вот";s:3:"286";s:6:"вој";s:3:"287";s:5:"ву ";s:3:"288";s:6:"доб";s:3:"289";s:6:"дру";s:3:"290";s:6:"дсе";s:3:"291";s:5:"ду ";s:3:"292";s:5:"е б";s:3:"293";s:5:"е д";s:3:"294";s:5:"е м";s:3:"295";s:5:"ем ";s:3:"296";s:6:"ема";s:3:"297";s:6:"ент";s:3:"298";s:6:"енц";s:3:"299";}s:6:"slovak";a:300:{s:3:" pr";s:1:"0";s:3:" po";s:1:"1";s:3:" ne";s:1:"2";s:3:" a ";s:1:"3";s:3:"ch ";s:1:"4";s:3:" na";s:1:"5";s:3:" je";s:1:"6";s:4:"ní ";s:1:"7";s:3:"je ";s:1:"8";s:3:" do";s:1:"9";s:3:"na ";s:2:"10";s:3:"ova";s:2:"11";s:3:" v ";s:2:"12";s:3:"to ";s:2:"13";s:3:"ho ";s:2:"14";s:3:"ou ";s:2:"15";s:3:" to";s:2:"16";s:3:"ick";s:2:"17";s:3:"ter";s:2:"18";s:4:"že ";s:2:"19";s:3:" st";s:2:"20";s:3:" za";s:2:"21";s:3:"ost";s:2:"22";s:4:"ých";s:2:"23";s:3:" se";s:2:"24";s:3:"pro";s:2:"25";s:3:" te";s:2:"26";s:3:"e s";s:2:"27";s:4:" že";s:2:"28";s:3:"a p";s:2:"29";s:3:" kt";s:2:"30";s:3:"pre";s:2:"31";s:3:" by";s:2:"32";s:3:" o ";s:2:"33";s:3:"se ";s:2:"34";s:3:"kon";s:2:"35";s:4:" př";s:2:"36";s:3:"a s";s:2:"37";s:4:"né ";s:2:"38";s:4:"ně ";s:2:"39";s:3:"sti";s:2:"40";s:3:"ako";s:2:"41";s:3:"ist";s:2:"42";s:3:"mu ";s:2:"43";s:3:"ame";s:2:"44";s:3:"ent";s:2:"45";s:3:"ky ";s:2:"46";s:3:"la ";s:2:"47";s:3:"pod";s:2:"48";s:3:" ve";s:2:"49";s:3:" ob";s:2:"50";s:3:"om ";s:2:"51";s:3:"vat";s:2:"52";s:3:" ko";s:2:"53";s:3:"sta";s:2:"54";s:3:"em ";s:2:"55";s:3:"le ";s:2:"56";s:3:"a v";s:2:"57";s:3:"by ";s:2:"58";s:3:"e p";s:2:"59";s:3:"ko ";s:2:"60";s:3:"eri";s:2:"61";s:3:"kte";s:2:"62";s:3:"sa ";s:2:"63";s:4:"ého";s:2:"64";s:3:"e v";s:2:"65";s:3:"mer";s:2:"66";s:3:"tel";s:2:"67";s:3:" ak";s:2:"68";s:3:" sv";s:2:"69";s:4:" zá";s:2:"70";s:3:"hla";s:2:"71";s:3:"las";s:2:"72";s:3:"lo ";s:2:"73";s:3:" ta";s:2:"74";s:3:"a n";s:2:"75";s:3:"ej ";s:2:"76";s:3:"li ";s:2:"77";s:3:"ne ";s:2:"78";s:3:" sa";s:2:"79";s:3:"ak ";s:2:"80";s:3:"ani";s:2:"81";s:3:"ate";s:2:"82";s:3:"ia ";s:2:"83";s:3:"sou";s:2:"84";s:3:" so";s:2:"85";s:4:"ení";s:2:"86";s:3:"ie ";s:2:"87";s:3:" re";s:2:"88";s:3:"ce ";s:2:"89";s:3:"e n";s:2:"90";s:3:"ori";s:2:"91";s:3:"tic";s:2:"92";s:3:" vy";s:2:"93";s:3:"a t";s:2:"94";s:4:"ké ";s:2:"95";s:3:"nos";s:2:"96";s:3:"o s";s:2:"97";s:3:"str";s:2:"98";s:3:"ti ";s:2:"99";s:3:"uje";s:3:"100";s:3:" sp";s:3:"101";s:3:"lov";s:3:"102";s:3:"o p";s:3:"103";s:3:"oli";s:3:"104";s:4:"ová";s:3:"105";s:4:" ná";s:3:"106";s:3:"ale";s:3:"107";s:3:"den";s:3:"108";s:3:"e o";s:3:"109";s:3:"ku ";s:3:"110";s:3:"val";s:3:"111";s:3:" am";s:3:"112";s:3:" ro";s:3:"113";s:3:" si";s:3:"114";s:3:"nie";s:3:"115";s:3:"pol";s:3:"116";s:3:"tra";s:3:"117";s:3:" al";s:3:"118";s:3:"ali";s:3:"119";s:3:"o v";s:3:"120";s:3:"tor";s:3:"121";s:3:" mo";s:3:"122";s:3:" ni";s:3:"123";s:3:"ci ";s:3:"124";s:3:"o n";s:3:"125";s:4:"ím ";s:3:"126";s:3:" le";s:3:"127";s:3:" pa";s:3:"128";s:3:" s ";s:3:"129";s:3:"al ";s:3:"130";s:3:"ati";s:3:"131";s:3:"ero";s:3:"132";s:3:"ove";s:3:"133";s:3:"rov";s:3:"134";s:4:"ván";s:3:"135";s:4:"ích";s:3:"136";s:3:" ja";s:3:"137";s:3:" z ";s:3:"138";s:4:"cké";s:3:"139";s:3:"e z";s:3:"140";s:3:" od";s:3:"141";s:3:"byl";s:3:"142";s:3:"de ";s:3:"143";s:3:"dob";s:3:"144";s:3:"nep";s:3:"145";s:3:"pra";s:3:"146";s:3:"ric";s:3:"147";s:3:"spo";s:3:"148";s:3:"tak";s:3:"149";s:4:" vš";s:3:"150";s:3:"a a";s:3:"151";s:3:"e t";s:3:"152";s:3:"lit";s:3:"153";s:3:"me ";s:3:"154";s:3:"nej";s:3:"155";s:3:"no ";s:3:"156";s:4:"nýc";s:3:"157";s:3:"o t";s:3:"158";s:3:"a j";s:3:"159";s:3:"e a";s:3:"160";s:3:"en ";s:3:"161";s:3:"est";s:3:"162";s:4:"jí ";s:3:"163";s:3:"mi ";s:3:"164";s:3:"slo";s:3:"165";s:4:"stá";s:3:"166";s:3:"u v";s:3:"167";s:3:"for";s:3:"168";s:3:"nou";s:3:"169";s:3:"pos";s:3:"170";s:4:"pře";s:3:"171";s:3:"si ";s:3:"172";s:3:"tom";s:3:"173";s:3:" vl";s:3:"174";s:3:"a z";s:3:"175";s:3:"ly ";s:3:"176";s:3:"orm";s:3:"177";s:3:"ris";s:3:"178";s:3:"za ";s:3:"179";s:4:"zák";s:3:"180";s:3:" k ";s:3:"181";s:3:"at ";s:3:"182";s:4:"cký";s:3:"183";s:3:"dno";s:3:"184";s:3:"dos";s:3:"185";s:3:"dy ";s:3:"186";s:3:"jak";s:3:"187";s:3:"kov";s:3:"188";s:3:"ny ";s:3:"189";s:3:"res";s:3:"190";s:3:"ror";s:3:"191";s:3:"sto";s:3:"192";s:3:"van";s:3:"193";s:3:" op";s:3:"194";s:3:"da ";s:3:"195";s:3:"do ";s:3:"196";s:3:"e j";s:3:"197";s:3:"hod";s:3:"198";s:3:"len";s:3:"199";s:4:"ný ";s:3:"200";s:3:"o z";s:3:"201";s:3:"poz";s:3:"202";s:3:"pri";s:3:"203";s:3:"ran";s:3:"204";s:3:"u s";s:3:"205";s:3:" ab";s:3:"206";s:3:"aj ";s:3:"207";s:3:"ast";s:3:"208";s:3:"it ";s:3:"209";s:3:"kto";s:3:"210";s:3:"o o";s:3:"211";s:3:"oby";s:3:"212";s:3:"odo";s:3:"213";s:3:"u p";s:3:"214";s:3:"va ";s:3:"215";s:5:"ání";s:3:"216";s:4:"í p";s:3:"217";s:4:"ým ";s:3:"218";s:3:" in";s:3:"219";s:3:" mi";s:3:"220";s:4:"ať ";s:3:"221";s:3:"dov";s:3:"222";s:3:"ka ";s:3:"223";s:3:"nsk";s:3:"224";s:4:"áln";s:3:"225";s:3:" an";s:3:"226";s:3:" bu";s:3:"227";s:3:" sl";s:3:"228";s:3:" tr";s:3:"229";s:3:"e m";s:3:"230";s:3:"ech";s:3:"231";s:3:"edn";s:3:"232";s:3:"i n";s:3:"233";s:4:"kýc";s:3:"234";s:4:"níc";s:3:"235";s:3:"ov ";s:3:"236";s:5:"pří";s:3:"237";s:4:"í a";s:3:"238";s:3:" aj";s:3:"239";s:3:" bo";s:3:"240";s:3:"a d";s:3:"241";s:3:"ide";s:3:"242";s:3:"o a";s:3:"243";s:3:"o d";s:3:"244";s:3:"och";s:3:"245";s:3:"pov";s:3:"246";s:3:"svo";s:3:"247";s:4:"é s";s:3:"248";s:3:" kd";s:3:"249";s:3:" vo";s:3:"250";s:4:" vý";s:3:"251";s:3:"bud";s:3:"252";s:3:"ich";s:3:"253";s:3:"il ";s:3:"254";s:3:"ili";s:3:"255";s:3:"ni ";s:3:"256";s:4:"ním";s:3:"257";s:3:"od ";s:3:"258";s:3:"osl";s:3:"259";s:3:"ouh";s:3:"260";s:3:"rav";s:3:"261";s:3:"roz";s:3:"262";s:3:"st ";s:3:"263";s:3:"stv";s:3:"264";s:3:"tu ";s:3:"265";s:3:"u a";s:3:"266";s:4:"vál";s:3:"267";s:3:"y s";s:3:"268";s:4:"í s";s:3:"269";s:4:"í v";s:3:"270";s:3:" hl";s:3:"271";s:3:" li";s:3:"272";s:3:" me";s:3:"273";s:3:"a m";s:3:"274";s:3:"e b";s:3:"275";s:3:"h s";s:3:"276";s:3:"i p";s:3:"277";s:3:"i s";s:3:"278";s:3:"iti";s:3:"279";s:4:"lád";s:3:"280";s:3:"nem";s:3:"281";s:3:"nov";s:3:"282";s:3:"opo";s:3:"283";s:3:"uhl";s:3:"284";s:3:"eno";s:3:"285";s:3:"ens";s:3:"286";s:3:"men";s:3:"287";s:3:"nes";s:3:"288";s:3:"obo";s:3:"289";s:3:"te ";s:3:"290";s:3:"ved";s:3:"291";s:4:"vlá";s:3:"292";s:3:"y n";s:3:"293";s:3:" ma";s:3:"294";s:3:" mu";s:3:"295";s:4:" vá";s:3:"296";s:3:"bez";s:3:"297";s:3:"byv";s:3:"298";s:3:"cho";s:3:"299";}s:7:"slovene";a:300:{s:3:"je ";s:1:"0";s:3:" pr";s:1:"1";s:3:" po";s:1:"2";s:3:" je";s:1:"3";s:3:" v ";s:1:"4";s:3:" za";s:1:"5";s:3:" na";s:1:"6";s:3:"pre";s:1:"7";s:3:"da ";s:1:"8";s:3:" da";s:1:"9";s:3:"ki ";s:2:"10";s:3:"ti ";s:2:"11";s:3:"ja ";s:2:"12";s:3:"ne ";s:2:"13";s:3:" in";s:2:"14";s:3:"in ";s:2:"15";s:3:"li ";s:2:"16";s:3:"no ";s:2:"17";s:3:"na ";s:2:"18";s:3:"ni ";s:2:"19";s:3:" bi";s:2:"20";s:3:"jo ";s:2:"21";s:3:" ne";s:2:"22";s:3:"nje";s:2:"23";s:3:"e p";s:2:"24";s:3:"i p";s:2:"25";s:3:"pri";s:2:"26";s:3:"o p";s:2:"27";s:3:"red";s:2:"28";s:3:" do";s:2:"29";s:3:"anj";s:2:"30";s:3:"em ";s:2:"31";s:3:"ih ";s:2:"32";s:3:" bo";s:2:"33";s:3:" ki";s:2:"34";s:3:" iz";s:2:"35";s:3:" se";s:2:"36";s:3:" so";s:2:"37";s:3:"al ";s:2:"38";s:3:" de";s:2:"39";s:3:"e v";s:2:"40";s:3:"i s";s:2:"41";s:3:"ko ";s:2:"42";s:3:"bil";s:2:"43";s:3:"ira";s:2:"44";s:3:"ove";s:2:"45";s:3:" br";s:2:"46";s:3:" ob";s:2:"47";s:3:"e b";s:2:"48";s:3:"i n";s:2:"49";s:3:"ova";s:2:"50";s:3:"se ";s:2:"51";s:3:"za ";s:2:"52";s:3:"la ";s:2:"53";s:3:" ja";s:2:"54";s:3:"ati";s:2:"55";s:3:"so ";s:2:"56";s:3:"ter";s:2:"57";s:3:" ta";s:2:"58";s:3:"a s";s:2:"59";s:3:"del";s:2:"60";s:3:"e d";s:2:"61";s:3:" dr";s:2:"62";s:3:" od";s:2:"63";s:3:"a n";s:2:"64";s:3:"ar ";s:2:"65";s:3:"jal";s:2:"66";s:3:"ji ";s:2:"67";s:3:"rit";s:2:"68";s:3:" ka";s:2:"69";s:3:" ko";s:2:"70";s:3:" pa";s:2:"71";s:3:"a b";s:2:"72";s:3:"ani";s:2:"73";s:3:"e s";s:2:"74";s:3:"er ";s:2:"75";s:3:"ili";s:2:"76";s:3:"lov";s:2:"77";s:3:"o v";s:2:"78";s:3:"tov";s:2:"79";s:3:" ir";s:2:"80";s:3:" ni";s:2:"81";s:3:" vo";s:2:"82";s:3:"a j";s:2:"83";s:3:"bi ";s:2:"84";s:3:"bri";s:2:"85";s:3:"iti";s:2:"86";s:3:"let";s:2:"87";s:3:"o n";s:2:"88";s:3:"tan";s:2:"89";s:4:"še ";s:2:"90";s:3:" le";s:2:"91";s:3:" te";s:2:"92";s:3:"eni";s:2:"93";s:3:"eri";s:2:"94";s:3:"ita";s:2:"95";s:3:"kat";s:2:"96";s:3:"por";s:2:"97";s:3:"pro";s:2:"98";s:3:"ali";s:2:"99";s:3:"ke ";s:3:"100";s:3:"oli";s:3:"101";s:3:"ov ";s:3:"102";s:3:"pra";s:3:"103";s:3:"ri ";s:3:"104";s:3:"uar";s:3:"105";s:3:"ve ";s:3:"106";s:3:" to";s:3:"107";s:3:"a i";s:3:"108";s:3:"a v";s:3:"109";s:3:"ako";s:3:"110";s:3:"arj";s:3:"111";s:3:"ate";s:3:"112";s:3:"di ";s:3:"113";s:3:"do ";s:3:"114";s:3:"ga ";s:3:"115";s:3:"le ";s:3:"116";s:3:"lo ";s:3:"117";s:3:"mer";s:3:"118";s:3:"o s";s:3:"119";s:3:"oda";s:3:"120";s:3:"oro";s:3:"121";s:3:"pod";s:3:"122";s:3:" ma";s:3:"123";s:3:" mo";s:3:"124";s:3:" si";s:3:"125";s:3:"a p";s:3:"126";s:3:"bod";s:3:"127";s:3:"e n";s:3:"128";s:3:"ega";s:3:"129";s:3:"ju ";s:3:"130";s:3:"ka ";s:3:"131";s:3:"lje";s:3:"132";s:3:"rav";s:3:"133";s:3:"ta ";s:3:"134";s:3:"a o";s:3:"135";s:3:"e t";s:3:"136";s:3:"e z";s:3:"137";s:3:"i d";s:3:"138";s:3:"i v";s:3:"139";s:3:"ila";s:3:"140";s:3:"lit";s:3:"141";s:3:"nih";s:3:"142";s:3:"odo";s:3:"143";s:3:"sti";s:3:"144";s:3:"to ";s:3:"145";s:3:"var";s:3:"146";s:3:"ved";s:3:"147";s:3:"vol";s:3:"148";s:3:" la";s:3:"149";s:3:" no";s:3:"150";s:3:" vs";s:3:"151";s:3:"a d";s:3:"152";s:3:"agu";s:3:"153";s:3:"aja";s:3:"154";s:3:"dej";s:3:"155";s:3:"dnj";s:3:"156";s:3:"eda";s:3:"157";s:3:"gov";s:3:"158";s:3:"gua";s:3:"159";s:3:"jag";s:3:"160";s:3:"jem";s:3:"161";s:3:"kon";s:3:"162";s:3:"ku ";s:3:"163";s:3:"nij";s:3:"164";s:3:"omo";s:3:"165";s:4:"oči";s:3:"166";s:3:"pov";s:3:"167";s:3:"rak";s:3:"168";s:3:"rja";s:3:"169";s:3:"sta";s:3:"170";s:3:"tev";s:3:"171";s:3:"a t";s:3:"172";s:3:"aj ";s:3:"173";s:3:"ed ";s:3:"174";s:3:"eja";s:3:"175";s:3:"ent";s:3:"176";s:3:"ev ";s:3:"177";s:3:"i i";s:3:"178";s:3:"i o";s:3:"179";s:3:"ijo";s:3:"180";s:3:"ist";s:3:"181";s:3:"ost";s:3:"182";s:3:"ske";s:3:"183";s:3:"str";s:3:"184";s:3:" ra";s:3:"185";s:3:" s ";s:3:"186";s:3:" tr";s:3:"187";s:4:" še";s:3:"188";s:3:"arn";s:3:"189";s:3:"bo ";s:3:"190";s:4:"drž";s:3:"191";s:3:"i j";s:3:"192";s:3:"ilo";s:3:"193";s:3:"izv";s:3:"194";s:3:"jen";s:3:"195";s:3:"lja";s:3:"196";s:3:"nsk";s:3:"197";s:3:"o d";s:3:"198";s:3:"o i";s:3:"199";s:3:"om ";s:3:"200";s:3:"ora";s:3:"201";s:3:"ovo";s:3:"202";s:3:"raz";s:3:"203";s:4:"rža";s:3:"204";s:3:"tak";s:3:"205";s:3:"va ";s:3:"206";s:3:"ven";s:3:"207";s:4:"žav";s:3:"208";s:3:" me";s:3:"209";s:4:" če";s:3:"210";s:3:"ame";s:3:"211";s:3:"avi";s:3:"212";s:3:"e i";s:3:"213";s:3:"e o";s:3:"214";s:3:"eka";s:3:"215";s:3:"gre";s:3:"216";s:3:"i t";s:3:"217";s:3:"ija";s:3:"218";s:3:"il ";s:3:"219";s:3:"ite";s:3:"220";s:3:"kra";s:3:"221";s:3:"lju";s:3:"222";s:3:"mor";s:3:"223";s:3:"nik";s:3:"224";s:3:"o t";s:3:"225";s:3:"obi";s:3:"226";s:3:"odn";s:3:"227";s:3:"ran";s:3:"228";s:3:"re ";s:3:"229";s:3:"sto";s:3:"230";s:3:"stv";s:3:"231";s:3:"udi";s:3:"232";s:3:"v i";s:3:"233";s:3:"van";s:3:"234";s:3:" am";s:3:"235";s:3:" sp";s:3:"236";s:3:" st";s:3:"237";s:3:" tu";s:3:"238";s:3:" ve";s:3:"239";s:4:" že";s:3:"240";s:3:"ajo";s:3:"241";s:3:"ale";s:3:"242";s:3:"apo";s:3:"243";s:3:"dal";s:3:"244";s:3:"dru";s:3:"245";s:3:"e j";s:3:"246";s:3:"edn";s:3:"247";s:3:"ejo";s:3:"248";s:3:"elo";s:3:"249";s:3:"est";s:3:"250";s:3:"etj";s:3:"251";s:3:"eva";s:3:"252";s:3:"iji";s:3:"253";s:3:"ik ";s:3:"254";s:3:"im ";s:3:"255";s:3:"itv";s:3:"256";s:3:"mob";s:3:"257";s:3:"nap";s:3:"258";s:3:"nek";s:3:"259";s:3:"pol";s:3:"260";s:3:"pos";s:3:"261";s:3:"rat";s:3:"262";s:3:"ski";s:3:"263";s:4:"tič";s:3:"264";s:3:"tom";s:3:"265";s:3:"ton";s:3:"266";s:3:"tra";s:3:"267";s:3:"tud";s:3:"268";s:3:"tve";s:3:"269";s:3:"v b";s:3:"270";s:3:"vil";s:3:"271";s:3:"vse";s:3:"272";s:4:"čit";s:3:"273";s:3:" av";s:3:"274";s:3:" gr";s:3:"275";s:3:"a z";s:3:"276";s:3:"ans";s:3:"277";s:3:"ast";s:3:"278";s:3:"avt";s:3:"279";s:3:"dan";s:3:"280";s:3:"e m";s:3:"281";s:3:"eds";s:3:"282";s:3:"for";s:3:"283";s:3:"i z";s:3:"284";s:3:"kot";s:3:"285";s:3:"mi ";s:3:"286";s:3:"nim";s:3:"287";s:3:"o b";s:3:"288";s:3:"o o";s:3:"289";s:3:"od ";s:3:"290";s:3:"odl";s:3:"291";s:3:"oiz";s:3:"292";s:3:"ot ";s:3:"293";s:3:"par";s:3:"294";s:3:"pot";s:3:"295";s:3:"rje";s:3:"296";s:3:"roi";s:3:"297";s:3:"tem";s:3:"298";s:3:"val";s:3:"299";}s:6:"somali";a:300:{s:3:"ka ";s:1:"0";s:3:"ay ";s:1:"1";s:3:"da ";s:1:"2";s:3:" ay";s:1:"3";s:3:"aal";s:1:"4";s:3:"oo ";s:1:"5";s:3:"aan";s:1:"6";s:3:" ka";s:1:"7";s:3:"an ";s:1:"8";s:3:"in ";s:1:"9";s:3:" in";s:2:"10";s:3:"ada";s:2:"11";s:3:"maa";s:2:"12";s:3:"aba";s:2:"13";s:3:" so";s:2:"14";s:3:"ali";s:2:"15";s:3:"bad";s:2:"16";s:3:"add";s:2:"17";s:3:"soo";s:2:"18";s:3:" na";s:2:"19";s:3:"aha";s:2:"20";s:3:"ku ";s:2:"21";s:3:"ta ";s:2:"22";s:3:" wa";s:2:"23";s:3:"yo ";s:2:"24";s:3:"a s";s:2:"25";s:3:"oma";s:2:"26";s:3:"yaa";s:2:"27";s:3:" ba";s:2:"28";s:3:" ku";s:2:"29";s:3:" la";s:2:"30";s:3:" oo";s:2:"31";s:3:"iya";s:2:"32";s:3:"sha";s:2:"33";s:3:"a a";s:2:"34";s:3:"dda";s:2:"35";s:3:"nab";s:2:"36";s:3:"nta";s:2:"37";s:3:" da";s:2:"38";s:3:" ma";s:2:"39";s:3:"nka";s:2:"40";s:3:"uu ";s:2:"41";s:3:"y i";s:2:"42";s:3:"aya";s:2:"43";s:3:"ha ";s:2:"44";s:3:"raa";s:2:"45";s:3:" dh";s:2:"46";s:3:" qa";s:2:"47";s:3:"a k";s:2:"48";s:3:"ala";s:2:"49";s:3:"baa";s:2:"50";s:3:"doo";s:2:"51";s:3:"had";s:2:"52";s:3:"liy";s:2:"53";s:3:"oom";s:2:"54";s:3:" ha";s:2:"55";s:3:" sh";s:2:"56";s:3:"a d";s:2:"57";s:3:"a i";s:2:"58";s:3:"a n";s:2:"59";s:3:"aar";s:2:"60";s:3:"ee ";s:2:"61";s:3:"ey ";s:2:"62";s:3:"y k";s:2:"63";s:3:"ya ";s:2:"64";s:3:" ee";s:2:"65";s:3:" iy";s:2:"66";s:3:"aa ";s:2:"67";s:3:"aaq";s:2:"68";s:3:"gaa";s:2:"69";s:3:"lam";s:2:"70";s:3:" bu";s:2:"71";s:3:"a b";s:2:"72";s:3:"a m";s:2:"73";s:3:"ad ";s:2:"74";s:3:"aga";s:2:"75";s:3:"ama";s:2:"76";s:3:"iyo";s:2:"77";s:3:"la ";s:2:"78";s:3:"a c";s:2:"79";s:3:"a l";s:2:"80";s:3:"een";s:2:"81";s:3:"int";s:2:"82";s:3:"she";s:2:"83";s:3:"wax";s:2:"84";s:3:"yee";s:2:"85";s:3:" si";s:2:"86";s:3:" uu";s:2:"87";s:3:"a h";s:2:"88";s:3:"aas";s:2:"89";s:3:"alk";s:2:"90";s:3:"dha";s:2:"91";s:3:"gu ";s:2:"92";s:3:"hee";s:2:"93";s:3:"ii ";s:2:"94";s:3:"ira";s:2:"95";s:3:"mad";s:2:"96";s:3:"o a";s:2:"97";s:3:"o k";s:2:"98";s:3:"qay";s:2:"99";s:3:" ah";s:3:"100";s:3:" ca";s:3:"101";s:3:" wu";s:3:"102";s:3:"ank";s:3:"103";s:3:"ash";s:3:"104";s:3:"axa";s:3:"105";s:3:"eed";s:3:"106";s:3:"en ";s:3:"107";s:3:"ga ";s:3:"108";s:3:"haa";s:3:"109";s:3:"n a";s:3:"110";s:3:"n s";s:3:"111";s:3:"naa";s:3:"112";s:3:"nay";s:3:"113";s:3:"o d";s:3:"114";s:3:"taa";s:3:"115";s:3:"u b";s:3:"116";s:3:"uxu";s:3:"117";s:3:"wux";s:3:"118";s:3:"xuu";s:3:"119";s:3:" ci";s:3:"120";s:3:" do";s:3:"121";s:3:" ho";s:3:"122";s:3:" ta";s:3:"123";s:3:"a g";s:3:"124";s:3:"a u";s:3:"125";s:3:"ana";s:3:"126";s:3:"ayo";s:3:"127";s:3:"dhi";s:3:"128";s:3:"iin";s:3:"129";s:3:"lag";s:3:"130";s:3:"lin";s:3:"131";s:3:"lka";s:3:"132";s:3:"o i";s:3:"133";s:3:"san";s:3:"134";s:3:"u s";s:3:"135";s:3:"una";s:3:"136";s:3:"uun";s:3:"137";s:3:" ga";s:3:"138";s:3:" xa";s:3:"139";s:3:" xu";s:3:"140";s:3:"aab";s:3:"141";s:3:"abt";s:3:"142";s:3:"aq ";s:3:"143";s:3:"aqa";s:3:"144";s:3:"ara";s:3:"145";s:3:"arl";s:3:"146";s:3:"caa";s:3:"147";s:3:"cir";s:3:"148";s:3:"eeg";s:3:"149";s:3:"eel";s:3:"150";s:3:"isa";s:3:"151";s:3:"kal";s:3:"152";s:3:"lah";s:3:"153";s:3:"ney";s:3:"154";s:3:"qaa";s:3:"155";s:3:"rla";s:3:"156";s:3:"sad";s:3:"157";s:3:"sii";s:3:"158";s:3:"u d";s:3:"159";s:3:"wad";s:3:"160";s:3:" ad";s:3:"161";s:3:" ar";s:3:"162";s:3:" di";s:3:"163";s:3:" jo";s:3:"164";s:3:" ra";s:3:"165";s:3:" sa";s:3:"166";s:3:" u ";s:3:"167";s:3:" yi";s:3:"168";s:3:"a j";s:3:"169";s:3:"a q";s:3:"170";s:3:"aad";s:3:"171";s:3:"aat";s:3:"172";s:3:"aay";s:3:"173";s:3:"ah ";s:3:"174";s:3:"ale";s:3:"175";s:3:"amk";s:3:"176";s:3:"ari";s:3:"177";s:3:"as ";s:3:"178";s:3:"aye";s:3:"179";s:3:"bus";s:3:"180";s:3:"dal";s:3:"181";s:3:"ddu";s:3:"182";s:3:"dii";s:3:"183";s:3:"du ";s:3:"184";s:3:"duu";s:3:"185";s:3:"ed ";s:3:"186";s:3:"ege";s:3:"187";s:3:"gey";s:3:"188";s:3:"hay";s:3:"189";s:3:"hii";s:3:"190";s:3:"ida";s:3:"191";s:3:"ine";s:3:"192";s:3:"joo";s:3:"193";s:3:"laa";s:3:"194";s:3:"lay";s:3:"195";s:3:"mar";s:3:"196";s:3:"mee";s:3:"197";s:3:"n b";s:3:"198";s:3:"n d";s:3:"199";s:3:"n m";s:3:"200";s:3:"no ";s:3:"201";s:3:"o b";s:3:"202";s:3:"o l";s:3:"203";s:3:"oog";s:3:"204";s:3:"oon";s:3:"205";s:3:"rga";s:3:"206";s:3:"sh ";s:3:"207";s:3:"sid";s:3:"208";s:3:"u q";s:3:"209";s:3:"unk";s:3:"210";s:3:"ush";s:3:"211";s:3:"xa ";s:3:"212";s:3:"y d";s:3:"213";s:3:" bi";s:3:"214";s:3:" gu";s:3:"215";s:3:" is";s:3:"216";s:3:" ke";s:3:"217";s:3:" lo";s:3:"218";s:3:" me";s:3:"219";s:3:" mu";s:3:"220";s:3:" qo";s:3:"221";s:3:" ug";s:3:"222";s:3:"a e";s:3:"223";s:3:"a o";s:3:"224";s:3:"a w";s:3:"225";s:3:"adi";s:3:"226";s:3:"ado";s:3:"227";s:3:"agu";s:3:"228";s:3:"al ";s:3:"229";s:3:"ant";s:3:"230";s:3:"ark";s:3:"231";s:3:"asa";s:3:"232";s:3:"awi";s:3:"233";s:3:"bta";s:3:"234";s:3:"bul";s:3:"235";s:3:"d a";s:3:"236";s:3:"dag";s:3:"237";s:3:"dan";s:3:"238";s:3:"do ";s:3:"239";s:3:"e s";s:3:"240";s:3:"gal";s:3:"241";s:3:"gay";s:3:"242";s:3:"guu";s:3:"243";s:3:"h e";s:3:"244";s:3:"hal";s:3:"245";s:3:"iga";s:3:"246";s:3:"ihi";s:3:"247";s:3:"iri";s:3:"248";s:3:"iye";s:3:"249";s:3:"ken";s:3:"250";s:3:"lad";s:3:"251";s:3:"lid";s:3:"252";s:3:"lsh";s:3:"253";s:3:"mag";s:3:"254";s:3:"mun";s:3:"255";s:3:"n h";s:3:"256";s:3:"n i";s:3:"257";s:3:"na ";s:3:"258";s:3:"o n";s:3:"259";s:3:"o w";s:3:"260";s:3:"ood";s:3:"261";s:3:"oor";s:3:"262";s:3:"ora";s:3:"263";s:3:"qab";s:3:"264";s:3:"qor";s:3:"265";s:3:"rab";s:3:"266";s:3:"rit";s:3:"267";s:3:"rta";s:3:"268";s:3:"s o";s:3:"269";s:3:"sab";s:3:"270";s:3:"ska";s:3:"271";s:3:"to ";s:3:"272";s:3:"u a";s:3:"273";s:3:"u h";s:3:"274";s:3:"u u";s:3:"275";s:3:"ud ";s:3:"276";s:3:"ugu";s:3:"277";s:3:"uls";s:3:"278";s:3:"uud";s:3:"279";s:3:"waa";s:3:"280";s:3:"xus";s:3:"281";s:3:"y b";s:3:"282";s:3:"y q";s:3:"283";s:3:"y s";s:3:"284";s:3:"yad";s:3:"285";s:3:"yay";s:3:"286";s:3:"yih";s:3:"287";s:3:" aa";s:3:"288";s:3:" bo";s:3:"289";s:3:" br";s:3:"290";s:3:" go";s:3:"291";s:3:" ji";s:3:"292";s:3:" mi";s:3:"293";s:3:" of";s:3:"294";s:3:" ti";s:3:"295";s:3:" um";s:3:"296";s:3:" wi";s:3:"297";s:3:" xo";s:3:"298";s:3:"a x";s:3:"299";}s:7:"spanish";a:300:{s:3:" de";s:1:"0";s:3:"de ";s:1:"1";s:3:" la";s:1:"2";s:3:"os ";s:1:"3";s:3:"la ";s:1:"4";s:3:"el ";s:1:"5";s:3:"es ";s:1:"6";s:3:" qu";s:1:"7";s:3:" co";s:1:"8";s:3:"e l";s:1:"9";s:3:"as ";s:2:"10";s:3:"que";s:2:"11";s:3:" el";s:2:"12";s:3:"ue ";s:2:"13";s:3:"en ";s:2:"14";s:3:"ent";s:2:"15";s:3:" en";s:2:"16";s:3:" se";s:2:"17";s:3:"nte";s:2:"18";s:3:"res";s:2:"19";s:3:"con";s:2:"20";s:3:"est";s:2:"21";s:3:" es";s:2:"22";s:3:"s d";s:2:"23";s:3:" lo";s:2:"24";s:3:" pr";s:2:"25";s:3:"los";s:2:"26";s:3:" y ";s:2:"27";s:3:"do ";s:2:"28";s:4:"ón ";s:2:"29";s:4:"ión";s:2:"30";s:3:" un";s:2:"31";s:4:"ció";s:2:"32";s:3:"del";s:2:"33";s:3:"o d";s:2:"34";s:3:" po";s:2:"35";s:3:"a d";s:2:"36";s:3:"aci";s:2:"37";s:3:"sta";s:2:"38";s:3:"te ";s:2:"39";s:3:"ado";s:2:"40";s:3:"pre";s:2:"41";s:3:"to ";s:2:"42";s:3:"par";s:2:"43";s:3:"a e";s:2:"44";s:3:"a l";s:2:"45";s:3:"ra ";s:2:"46";s:3:"al ";s:2:"47";s:3:"e e";s:2:"48";s:3:"se ";s:2:"49";s:3:"pro";s:2:"50";s:3:"ar ";s:2:"51";s:3:"ia ";s:2:"52";s:3:"o e";s:2:"53";s:3:" re";s:2:"54";s:3:"ida";s:2:"55";s:3:"dad";s:2:"56";s:3:"tra";s:2:"57";s:3:"por";s:2:"58";s:3:"s p";s:2:"59";s:3:" a ";s:2:"60";s:3:"a p";s:2:"61";s:3:"ara";s:2:"62";s:3:"cia";s:2:"63";s:3:" pa";s:2:"64";s:3:"com";s:2:"65";s:3:"no ";s:2:"66";s:3:" di";s:2:"67";s:3:" in";s:2:"68";s:3:"ien";s:2:"69";s:3:"n l";s:2:"70";s:3:"ad ";s:2:"71";s:3:"ant";s:2:"72";s:3:"e s";s:2:"73";s:3:"men";s:2:"74";s:3:"a c";s:2:"75";s:3:"on ";s:2:"76";s:3:"un ";s:2:"77";s:3:"las";s:2:"78";s:3:"nci";s:2:"79";s:3:" tr";s:2:"80";s:3:"cio";s:2:"81";s:3:"ier";s:2:"82";s:3:"nto";s:2:"83";s:3:"tiv";s:2:"84";s:3:"n d";s:2:"85";s:3:"n e";s:2:"86";s:3:"or ";s:2:"87";s:3:"s c";s:2:"88";s:3:"enc";s:2:"89";s:3:"ern";s:2:"90";s:3:"io ";s:2:"91";s:3:"a s";s:2:"92";s:3:"ici";s:2:"93";s:3:"s e";s:2:"94";s:3:" ma";s:2:"95";s:3:"dos";s:2:"96";s:3:"e a";s:2:"97";s:3:"e c";s:2:"98";s:3:"emp";s:2:"99";s:3:"ica";s:3:"100";s:3:"ivo";s:3:"101";s:3:"l p";s:3:"102";s:3:"n c";s:3:"103";s:3:"r e";s:3:"104";s:3:"ta ";s:3:"105";s:3:"ter";s:3:"106";s:3:"e d";s:3:"107";s:3:"esa";s:3:"108";s:3:"ez ";s:3:"109";s:3:"mpr";s:3:"110";s:3:"o a";s:3:"111";s:3:"s a";s:3:"112";s:3:" ca";s:3:"113";s:3:" su";s:3:"114";s:3:"ion";s:3:"115";s:3:" cu";s:3:"116";s:3:" ju";s:3:"117";s:3:"an ";s:3:"118";s:3:"da ";s:3:"119";s:3:"ene";s:3:"120";s:3:"ero";s:3:"121";s:3:"na ";s:3:"122";s:3:"rec";s:3:"123";s:3:"ro ";s:3:"124";s:3:"tar";s:3:"125";s:3:" al";s:3:"126";s:3:" an";s:3:"127";s:3:"bie";s:3:"128";s:3:"e p";s:3:"129";s:3:"er ";s:3:"130";s:3:"l c";s:3:"131";s:3:"n p";s:3:"132";s:3:"omp";s:3:"133";s:3:"ten";s:3:"134";s:3:" em";s:3:"135";s:3:"ist";s:3:"136";s:3:"nes";s:3:"137";s:3:"nta";s:3:"138";s:3:"o c";s:3:"139";s:3:"so ";s:3:"140";s:3:"tes";s:3:"141";s:3:"era";s:3:"142";s:3:"l d";s:3:"143";s:3:"l m";s:3:"144";s:3:"les";s:3:"145";s:3:"ntr";s:3:"146";s:3:"o s";s:3:"147";s:3:"ore";s:3:"148";s:4:"rá ";s:3:"149";s:3:"s q";s:3:"150";s:3:"s y";s:3:"151";s:3:"sto";s:3:"152";s:3:"a a";s:3:"153";s:3:"a r";s:3:"154";s:3:"ari";s:3:"155";s:3:"des";s:3:"156";s:3:"e q";s:3:"157";s:3:"ivi";s:3:"158";s:3:"lic";s:3:"159";s:3:"lo ";s:3:"160";s:3:"n a";s:3:"161";s:3:"one";s:3:"162";s:3:"ora";s:3:"163";s:3:"per";s:3:"164";s:3:"pue";s:3:"165";s:3:"r l";s:3:"166";s:3:"re ";s:3:"167";s:3:"ren";s:3:"168";s:3:"una";s:3:"169";s:4:"ía ";s:3:"170";s:3:"ada";s:3:"171";s:3:"cas";s:3:"172";s:3:"ere";s:3:"173";s:3:"ide";s:3:"174";s:3:"min";s:3:"175";s:3:"n s";s:3:"176";s:3:"ndo";s:3:"177";s:3:"ran";s:3:"178";s:3:"rno";s:3:"179";s:3:" ac";s:3:"180";s:3:" ex";s:3:"181";s:3:" go";s:3:"182";s:3:" no";s:3:"183";s:3:"a t";s:3:"184";s:3:"aba";s:3:"185";s:3:"ble";s:3:"186";s:3:"ece";s:3:"187";s:3:"ect";s:3:"188";s:3:"l a";s:3:"189";s:3:"l g";s:3:"190";s:3:"lid";s:3:"191";s:3:"nsi";s:3:"192";s:3:"ons";s:3:"193";s:3:"rac";s:3:"194";s:3:"rio";s:3:"195";s:3:"str";s:3:"196";s:3:"uer";s:3:"197";s:3:"ust";s:3:"198";s:3:" ha";s:3:"199";s:3:" le";s:3:"200";s:3:" mi";s:3:"201";s:3:" mu";s:3:"202";s:3:" ob";s:3:"203";s:3:" pe";s:3:"204";s:3:" pu";s:3:"205";s:3:" so";s:3:"206";s:3:"a i";s:3:"207";s:3:"ale";s:3:"208";s:3:"ca ";s:3:"209";s:3:"cto";s:3:"210";s:3:"e i";s:3:"211";s:3:"e u";s:3:"212";s:3:"eso";s:3:"213";s:3:"fer";s:3:"214";s:3:"fic";s:3:"215";s:3:"gob";s:3:"216";s:3:"jo ";s:3:"217";s:3:"ma ";s:3:"218";s:3:"mpl";s:3:"219";s:3:"o p";s:3:"220";s:3:"obi";s:3:"221";s:3:"s m";s:3:"222";s:3:"sa ";s:3:"223";s:3:"sep";s:3:"224";s:3:"ste";s:3:"225";s:3:"sti";s:3:"226";s:3:"tad";s:3:"227";s:3:"tod";s:3:"228";s:3:"y s";s:3:"229";s:3:" ci";s:3:"230";s:3:"and";s:3:"231";s:3:"ces";s:3:"232";s:4:"có ";s:3:"233";s:3:"dor";s:3:"234";s:3:"e m";s:3:"235";s:3:"eci";s:3:"236";s:3:"eco";s:3:"237";s:3:"esi";s:3:"238";s:3:"int";s:3:"239";s:3:"iza";s:3:"240";s:3:"l e";s:3:"241";s:3:"lar";s:3:"242";s:3:"mie";s:3:"243";s:3:"ner";s:3:"244";s:3:"orc";s:3:"245";s:3:"rci";s:3:"246";s:3:"ria";s:3:"247";s:3:"tic";s:3:"248";s:3:"tor";s:3:"249";s:3:" as";s:3:"250";s:3:" si";s:3:"251";s:3:"ce ";s:3:"252";s:3:"den";s:3:"253";s:3:"e r";s:3:"254";s:3:"e t";s:3:"255";s:3:"end";s:3:"256";s:3:"eri";s:3:"257";s:3:"esp";s:3:"258";s:3:"ial";s:3:"259";s:3:"ido";s:3:"260";s:3:"ina";s:3:"261";s:3:"inc";s:3:"262";s:3:"mit";s:3:"263";s:3:"o l";s:3:"264";s:3:"ome";s:3:"265";s:3:"pli";s:3:"266";s:3:"ras";s:3:"267";s:3:"s t";s:3:"268";s:3:"sid";s:3:"269";s:3:"sup";s:3:"270";s:3:"tab";s:3:"271";s:3:"uen";s:3:"272";s:3:"ues";s:3:"273";s:3:"ura";s:3:"274";s:3:"vo ";s:3:"275";s:3:"vor";s:3:"276";s:3:" sa";s:3:"277";s:3:" ti";s:3:"278";s:3:"abl";s:3:"279";s:3:"ali";s:3:"280";s:3:"aso";s:3:"281";s:3:"ast";s:3:"282";s:3:"cor";s:3:"283";s:3:"cti";s:3:"284";s:3:"cue";s:3:"285";s:3:"div";s:3:"286";s:3:"duc";s:3:"287";s:3:"ens";s:3:"288";s:3:"eti";s:3:"289";s:3:"imi";s:3:"290";s:3:"ini";s:3:"291";s:3:"lec";s:3:"292";s:3:"o q";s:3:"293";s:3:"oce";s:3:"294";s:3:"ort";s:3:"295";s:3:"ral";s:3:"296";s:3:"rma";s:3:"297";s:3:"roc";s:3:"298";s:3:"rod";s:3:"299";}s:7:"swahili";a:300:{s:3:" wa";s:1:"0";s:3:"wa ";s:1:"1";s:3:"a k";s:1:"2";s:3:"a m";s:1:"3";s:3:" ku";s:1:"4";s:3:" ya";s:1:"5";s:3:"a w";s:1:"6";s:3:"ya ";s:1:"7";s:3:"ni ";s:1:"8";s:3:" ma";s:1:"9";s:3:"ka ";s:2:"10";s:3:"a u";s:2:"11";s:3:"na ";s:2:"12";s:3:"za ";s:2:"13";s:3:"ia ";s:2:"14";s:3:" na";s:2:"15";s:3:"ika";s:2:"16";s:3:"ma ";s:2:"17";s:3:"ali";s:2:"18";s:3:"a n";s:2:"19";s:3:" am";s:2:"20";s:3:"ili";s:2:"21";s:3:"kwa";s:2:"22";s:3:" kw";s:2:"23";s:3:"ini";s:2:"24";s:3:" ha";s:2:"25";s:3:"ame";s:2:"26";s:3:"ana";s:2:"27";s:3:"i n";s:2:"28";s:3:" za";s:2:"29";s:3:"a h";s:2:"30";s:3:"ema";s:2:"31";s:3:"i m";s:2:"32";s:3:"i y";s:2:"33";s:3:"kuw";s:2:"34";s:3:"la ";s:2:"35";s:3:"o w";s:2:"36";s:3:"a y";s:2:"37";s:3:"ata";s:2:"38";s:3:"sem";s:2:"39";s:3:" la";s:2:"40";s:3:"ati";s:2:"41";s:3:"chi";s:2:"42";s:3:"i w";s:2:"43";s:3:"uwa";s:2:"44";s:3:"aki";s:2:"45";s:3:"li ";s:2:"46";s:3:"eka";s:2:"47";s:3:"ira";s:2:"48";s:3:" nc";s:2:"49";s:3:"a s";s:2:"50";s:3:"iki";s:2:"51";s:3:"kat";s:2:"52";s:3:"nch";s:2:"53";s:3:" ka";s:2:"54";s:3:" ki";s:2:"55";s:3:"a b";s:2:"56";s:3:"aji";s:2:"57";s:3:"amb";s:2:"58";s:3:"ra ";s:2:"59";s:3:"ri ";s:2:"60";s:3:"rik";s:2:"61";s:3:"ada";s:2:"62";s:3:"mat";s:2:"63";s:3:"mba";s:2:"64";s:3:"mes";s:2:"65";s:3:"yo ";s:2:"66";s:3:"zi ";s:2:"67";s:3:"da ";s:2:"68";s:3:"hi ";s:2:"69";s:3:"i k";s:2:"70";s:3:"ja ";s:2:"71";s:3:"kut";s:2:"72";s:3:"tek";s:2:"73";s:3:"wan";s:2:"74";s:3:" bi";s:2:"75";s:3:"a a";s:2:"76";s:3:"aka";s:2:"77";s:3:"ao ";s:2:"78";s:3:"asi";s:2:"79";s:3:"cha";s:2:"80";s:3:"ese";s:2:"81";s:3:"eza";s:2:"82";s:3:"ke ";s:2:"83";s:3:"moj";s:2:"84";s:3:"oja";s:2:"85";s:3:" hi";s:2:"86";s:3:"a z";s:2:"87";s:3:"end";s:2:"88";s:3:"ha ";s:2:"89";s:3:"ji ";s:2:"90";s:3:"mu ";s:2:"91";s:3:"shi";s:2:"92";s:3:"wat";s:2:"93";s:3:" bw";s:2:"94";s:3:"ake";s:2:"95";s:3:"ara";s:2:"96";s:3:"bw ";s:2:"97";s:3:"i h";s:2:"98";s:3:"imb";s:2:"99";s:3:"tik";s:3:"100";s:3:"wak";s:3:"101";s:3:"wal";s:3:"102";s:3:" hu";s:3:"103";s:3:" mi";s:3:"104";s:3:" mk";s:3:"105";s:3:" ni";s:3:"106";s:3:" ra";s:3:"107";s:3:" um";s:3:"108";s:3:"a l";s:3:"109";s:3:"ate";s:3:"110";s:3:"esh";s:3:"111";s:3:"ina";s:3:"112";s:3:"ish";s:3:"113";s:3:"kim";s:3:"114";s:3:"o k";s:3:"115";s:3:" ir";s:3:"116";s:3:"a i";s:3:"117";s:3:"ala";s:3:"118";s:3:"ani";s:3:"119";s:3:"aq ";s:3:"120";s:3:"azi";s:3:"121";s:3:"hin";s:3:"122";s:3:"i a";s:3:"123";s:3:"idi";s:3:"124";s:3:"ima";s:3:"125";s:3:"ita";s:3:"126";s:3:"rai";s:3:"127";s:3:"raq";s:3:"128";s:3:"sha";s:3:"129";s:3:" ms";s:3:"130";s:3:" se";s:3:"131";s:3:"afr";s:3:"132";s:3:"ama";s:3:"133";s:3:"ano";s:3:"134";s:3:"ea ";s:3:"135";s:3:"ele";s:3:"136";s:3:"fri";s:3:"137";s:3:"go ";s:3:"138";s:3:"i i";s:3:"139";s:3:"ifa";s:3:"140";s:3:"iwa";s:3:"141";s:3:"iyo";s:3:"142";s:3:"kus";s:3:"143";s:3:"lia";s:3:"144";s:3:"lio";s:3:"145";s:3:"maj";s:3:"146";s:3:"mku";s:3:"147";s:3:"no ";s:3:"148";s:3:"tan";s:3:"149";s:3:"uli";s:3:"150";s:3:"uta";s:3:"151";s:3:"wen";s:3:"152";s:3:" al";s:3:"153";s:3:"a j";s:3:"154";s:3:"aad";s:3:"155";s:3:"aid";s:3:"156";s:3:"ari";s:3:"157";s:3:"awa";s:3:"158";s:3:"ba ";s:3:"159";s:3:"fa ";s:3:"160";s:3:"nde";s:3:"161";s:3:"nge";s:3:"162";s:3:"nya";s:3:"163";s:3:"o y";s:3:"164";s:3:"u w";s:3:"165";s:3:"ua ";s:3:"166";s:3:"umo";s:3:"167";s:3:"waz";s:3:"168";s:3:"ye ";s:3:"169";s:3:" ut";s:3:"170";s:3:" vi";s:3:"171";s:3:"a d";s:3:"172";s:3:"a t";s:3:"173";s:3:"aif";s:3:"174";s:3:"di ";s:3:"175";s:3:"ere";s:3:"176";s:3:"ing";s:3:"177";s:3:"kin";s:3:"178";s:3:"nda";s:3:"179";s:3:"o n";s:3:"180";s:3:"oa ";s:3:"181";s:3:"tai";s:3:"182";s:3:"toa";s:3:"183";s:3:"usa";s:3:"184";s:3:"uto";s:3:"185";s:3:"was";s:3:"186";s:3:"yak";s:3:"187";s:3:"zo ";s:3:"188";s:3:" ji";s:3:"189";s:3:" mw";s:3:"190";s:3:"a p";s:3:"191";s:3:"aia";s:3:"192";s:3:"amu";s:3:"193";s:3:"ang";s:3:"194";s:3:"bik";s:3:"195";s:3:"bo ";s:3:"196";s:3:"del";s:3:"197";s:3:"e w";s:3:"198";s:3:"ene";s:3:"199";s:3:"eng";s:3:"200";s:3:"ich";s:3:"201";s:3:"iri";s:3:"202";s:3:"iti";s:3:"203";s:3:"ito";s:3:"204";s:3:"ki ";s:3:"205";s:3:"kir";s:3:"206";s:3:"ko ";s:3:"207";s:3:"kuu";s:3:"208";s:3:"mar";s:3:"209";s:3:"mbo";s:3:"210";s:3:"mil";s:3:"211";s:3:"ngi";s:3:"212";s:3:"ngo";s:3:"213";s:3:"o l";s:3:"214";s:3:"ong";s:3:"215";s:3:"si ";s:3:"216";s:3:"ta ";s:3:"217";s:3:"tak";s:3:"218";s:3:"u y";s:3:"219";s:3:"umu";s:3:"220";s:3:"usi";s:3:"221";s:3:"uu ";s:3:"222";s:3:"wam";s:3:"223";s:3:" af";s:3:"224";s:3:" ba";s:3:"225";s:3:" li";s:3:"226";s:3:" si";s:3:"227";s:3:" zi";s:3:"228";s:3:"a v";s:3:"229";s:3:"ami";s:3:"230";s:3:"atu";s:3:"231";s:3:"awi";s:3:"232";s:3:"eri";s:3:"233";s:3:"fan";s:3:"234";s:3:"fur";s:3:"235";s:3:"ger";s:3:"236";s:3:"i z";s:3:"237";s:3:"isi";s:3:"238";s:3:"izo";s:3:"239";s:3:"lea";s:3:"240";s:3:"mbi";s:3:"241";s:3:"mwa";s:3:"242";s:3:"nye";s:3:"243";s:3:"o h";s:3:"244";s:3:"o m";s:3:"245";s:3:"oni";s:3:"246";s:3:"rez";s:3:"247";s:3:"saa";s:3:"248";s:3:"ser";s:3:"249";s:3:"sin";s:3:"250";s:3:"tat";s:3:"251";s:3:"tis";s:3:"252";s:3:"tu ";s:3:"253";s:3:"uin";s:3:"254";s:3:"uki";s:3:"255";s:3:"ur ";s:3:"256";s:3:"wi ";s:3:"257";s:3:"yar";s:3:"258";s:3:" da";s:3:"259";s:3:" en";s:3:"260";s:3:" mp";s:3:"261";s:3:" ny";s:3:"262";s:3:" ta";s:3:"263";s:3:" ul";s:3:"264";s:3:" we";s:3:"265";s:3:"a c";s:3:"266";s:3:"a f";s:3:"267";s:3:"ais";s:3:"268";s:3:"apo";s:3:"269";s:3:"ayo";s:3:"270";s:3:"bar";s:3:"271";s:3:"dhi";s:3:"272";s:3:"e a";s:3:"273";s:3:"eke";s:3:"274";s:3:"eny";s:3:"275";s:3:"eon";s:3:"276";s:3:"hai";s:3:"277";s:3:"han";s:3:"278";s:3:"hiy";s:3:"279";s:3:"hur";s:3:"280";s:3:"i s";s:3:"281";s:3:"imw";s:3:"282";s:3:"kal";s:3:"283";s:3:"kwe";s:3:"284";s:3:"lak";s:3:"285";s:3:"lam";s:3:"286";s:3:"mak";s:3:"287";s:3:"msa";s:3:"288";s:3:"ne ";s:3:"289";s:3:"ngu";s:3:"290";s:3:"ru ";s:3:"291";s:3:"sal";s:3:"292";s:3:"swa";s:3:"293";s:3:"te ";s:3:"294";s:3:"ti ";s:3:"295";s:3:"uku";s:3:"296";s:3:"uma";s:3:"297";s:3:"una";s:3:"298";s:3:"uru";s:3:"299";}s:7:"swedish";a:300:{s:3:"en ";s:1:"0";s:3:" de";s:1:"1";s:3:"et ";s:1:"2";s:3:"er ";s:1:"3";s:3:"tt ";s:1:"4";s:3:"om ";s:1:"5";s:4:"för";s:1:"6";s:3:"ar ";s:1:"7";s:3:"de ";s:1:"8";s:3:"att";s:1:"9";s:4:" fö";s:2:"10";s:3:"ing";s:2:"11";s:3:" in";s:2:"12";s:3:" at";s:2:"13";s:3:" i ";s:2:"14";s:3:"det";s:2:"15";s:3:"ch ";s:2:"16";s:3:"an ";s:2:"17";s:3:"gen";s:2:"18";s:3:" an";s:2:"19";s:3:"t s";s:2:"20";s:3:"som";s:2:"21";s:3:"te ";s:2:"22";s:3:" oc";s:2:"23";s:3:"ter";s:2:"24";s:3:" ha";s:2:"25";s:3:"lle";s:2:"26";s:3:"och";s:2:"27";s:3:" sk";s:2:"28";s:3:" so";s:2:"29";s:3:"ra ";s:2:"30";s:3:"r a";s:2:"31";s:3:" me";s:2:"32";s:3:"var";s:2:"33";s:3:"nde";s:2:"34";s:4:"är ";s:2:"35";s:3:" ko";s:2:"36";s:3:"on ";s:2:"37";s:3:"ans";s:2:"38";s:3:"int";s:2:"39";s:3:"n s";s:2:"40";s:3:"na ";s:2:"41";s:3:" en";s:2:"42";s:3:" fr";s:2:"43";s:4:" på";s:2:"44";s:3:" st";s:2:"45";s:3:" va";s:2:"46";s:3:"and";s:2:"47";s:3:"nte";s:2:"48";s:4:"på ";s:2:"49";s:3:"ska";s:2:"50";s:3:"ta ";s:2:"51";s:3:" vi";s:2:"52";s:3:"der";s:2:"53";s:4:"äll";s:2:"54";s:4:"örs";s:2:"55";s:3:" om";s:2:"56";s:3:"da ";s:2:"57";s:3:"kri";s:2:"58";s:3:"ka ";s:2:"59";s:3:"nst";s:2:"60";s:3:" ho";s:2:"61";s:3:"as ";s:2:"62";s:4:"stä";s:2:"63";s:3:"r d";s:2:"64";s:3:"t f";s:2:"65";s:3:"upp";s:2:"66";s:3:" be";s:2:"67";s:3:"nge";s:2:"68";s:3:"r s";s:2:"69";s:3:"tal";s:2:"70";s:4:"täl";s:2:"71";s:4:"ör ";s:2:"72";s:3:" av";s:2:"73";s:3:"ger";s:2:"74";s:3:"ill";s:2:"75";s:3:"ng ";s:2:"76";s:3:"e s";s:2:"77";s:3:"ekt";s:2:"78";s:3:"ade";s:2:"79";s:3:"era";s:2:"80";s:3:"ers";s:2:"81";s:3:"har";s:2:"82";s:3:"ll ";s:2:"83";s:3:"lld";s:2:"84";s:3:"rin";s:2:"85";s:3:"rna";s:2:"86";s:4:"säk";s:2:"87";s:3:"und";s:2:"88";s:3:"inn";s:2:"89";s:3:"lig";s:2:"90";s:3:"ns ";s:2:"91";s:3:" ma";s:2:"92";s:3:" pr";s:2:"93";s:3:" up";s:2:"94";s:3:"age";s:2:"95";s:3:"av ";s:2:"96";s:3:"iva";s:2:"97";s:3:"kti";s:2:"98";s:3:"lda";s:2:"99";s:3:"orn";s:3:"100";s:3:"son";s:3:"101";s:3:"ts ";s:3:"102";s:3:"tta";s:3:"103";s:4:"äkr";s:3:"104";s:3:" sj";s:3:"105";s:3:" ti";s:3:"106";s:3:"avt";s:3:"107";s:3:"ber";s:3:"108";s:3:"els";s:3:"109";s:3:"eta";s:3:"110";s:3:"kol";s:3:"111";s:3:"men";s:3:"112";s:3:"n d";s:3:"113";s:3:"t k";s:3:"114";s:3:"vta";s:3:"115";s:4:"år ";s:3:"116";s:3:"juk";s:3:"117";s:3:"man";s:3:"118";s:3:"n f";s:3:"119";s:3:"nin";s:3:"120";s:3:"r i";s:3:"121";s:4:"rsä";s:3:"122";s:3:"sju";s:3:"123";s:3:"sso";s:3:"124";s:4:" är";s:3:"125";s:3:"a s";s:3:"126";s:3:"ach";s:3:"127";s:3:"ag ";s:3:"128";s:3:"bac";s:3:"129";s:3:"den";s:3:"130";s:3:"ett";s:3:"131";s:3:"fte";s:3:"132";s:3:"hor";s:3:"133";s:3:"nba";s:3:"134";s:3:"oll";s:3:"135";s:3:"rnb";s:3:"136";s:3:"ste";s:3:"137";s:3:"til";s:3:"138";s:3:" ef";s:3:"139";s:3:" si";s:3:"140";s:3:"a a";s:3:"141";s:3:"e h";s:3:"142";s:3:"ed ";s:3:"143";s:3:"eft";s:3:"144";s:3:"ga ";s:3:"145";s:3:"ig ";s:3:"146";s:3:"it ";s:3:"147";s:3:"ler";s:3:"148";s:3:"med";s:3:"149";s:3:"n i";s:3:"150";s:3:"nd ";s:3:"151";s:4:"så ";s:3:"152";s:3:"tiv";s:3:"153";s:3:" bl";s:3:"154";s:3:" et";s:3:"155";s:3:" fi";s:3:"156";s:4:" sä";s:3:"157";s:3:"at ";s:3:"158";s:3:"des";s:3:"159";s:3:"e a";s:3:"160";s:3:"gar";s:3:"161";s:3:"get";s:3:"162";s:3:"lan";s:3:"163";s:3:"lss";s:3:"164";s:3:"ost";s:3:"165";s:3:"r b";s:3:"166";s:3:"r e";s:3:"167";s:3:"re ";s:3:"168";s:3:"ret";s:3:"169";s:3:"sta";s:3:"170";s:3:"t i";s:3:"171";s:3:" ge";s:3:"172";s:3:" he";s:3:"173";s:3:" re";s:3:"174";s:3:"a f";s:3:"175";s:3:"all";s:3:"176";s:3:"bos";s:3:"177";s:3:"ets";s:3:"178";s:3:"lek";s:3:"179";s:3:"let";s:3:"180";s:3:"ner";s:3:"181";s:3:"nna";s:3:"182";s:3:"nne";s:3:"183";s:3:"r f";s:3:"184";s:3:"rit";s:3:"185";s:3:"s s";s:3:"186";s:3:"sen";s:3:"187";s:3:"sto";s:3:"188";s:3:"tor";s:3:"189";s:3:"vav";s:3:"190";s:3:"ygg";s:3:"191";s:3:" ka";s:3:"192";s:4:" så";s:3:"193";s:3:" tr";s:3:"194";s:3:" ut";s:3:"195";s:3:"ad ";s:3:"196";s:3:"al ";s:3:"197";s:3:"are";s:3:"198";s:3:"e o";s:3:"199";s:3:"gon";s:3:"200";s:3:"kom";s:3:"201";s:3:"n a";s:3:"202";s:3:"n h";s:3:"203";s:3:"nga";s:3:"204";s:3:"r h";s:3:"205";s:3:"ren";s:3:"206";s:3:"t d";s:3:"207";s:3:"tag";s:3:"208";s:3:"tar";s:3:"209";s:3:"tre";s:3:"210";s:4:"ätt";s:3:"211";s:4:" få";s:3:"212";s:4:" hä";s:3:"213";s:3:" se";s:3:"214";s:3:"a d";s:3:"215";s:3:"a i";s:3:"216";s:3:"a p";s:3:"217";s:3:"ale";s:3:"218";s:3:"ann";s:3:"219";s:3:"ara";s:3:"220";s:3:"byg";s:3:"221";s:3:"gt ";s:3:"222";s:3:"han";s:3:"223";s:3:"igt";s:3:"224";s:3:"kan";s:3:"225";s:3:"la ";s:3:"226";s:3:"n o";s:3:"227";s:3:"nom";s:3:"228";s:3:"nsk";s:3:"229";s:3:"omm";s:3:"230";s:3:"r k";s:3:"231";s:3:"r p";s:3:"232";s:3:"r v";s:3:"233";s:3:"s f";s:3:"234";s:3:"s k";s:3:"235";s:3:"t a";s:3:"236";s:3:"t p";s:3:"237";s:3:"ver";s:3:"238";s:3:" bo";s:3:"239";s:3:" br";s:3:"240";s:3:" ku";s:3:"241";s:4:" nå";s:3:"242";s:3:"a b";s:3:"243";s:3:"a e";s:3:"244";s:3:"del";s:3:"245";s:3:"ens";s:3:"246";s:3:"es ";s:3:"247";s:3:"fin";s:3:"248";s:3:"ige";s:3:"249";s:3:"m s";s:3:"250";s:3:"n p";s:3:"251";s:4:"någ";s:3:"252";s:3:"or ";s:3:"253";s:3:"r o";s:3:"254";s:3:"rbe";s:3:"255";s:3:"rs ";s:3:"256";s:3:"rt ";s:3:"257";s:3:"s a";s:3:"258";s:3:"s n";s:3:"259";s:3:"skr";s:3:"260";s:3:"t o";s:3:"261";s:3:"ten";s:3:"262";s:3:"tio";s:3:"263";s:3:"ven";s:3:"264";s:3:" al";s:3:"265";s:3:" ja";s:3:"266";s:3:" p ";s:3:"267";s:3:" r ";s:3:"268";s:3:" sa";s:3:"269";s:3:"a h";s:3:"270";s:3:"bet";s:3:"271";s:3:"cke";s:3:"272";s:3:"dra";s:3:"273";s:3:"e f";s:3:"274";s:3:"e i";s:3:"275";s:3:"eda";s:3:"276";s:3:"eno";s:3:"277";s:4:"erä";s:3:"278";s:3:"ess";s:3:"279";s:3:"ion";s:3:"280";s:3:"jag";s:3:"281";s:3:"m f";s:3:"282";s:3:"ne ";s:3:"283";s:3:"nns";s:3:"284";s:3:"pro";s:3:"285";s:3:"r t";s:3:"286";s:3:"rar";s:3:"287";s:3:"riv";s:3:"288";s:4:"rät";s:3:"289";s:3:"t e";s:3:"290";s:3:"t t";s:3:"291";s:3:"ust";s:3:"292";s:3:"vad";s:3:"293";s:4:"öre";s:3:"294";s:3:" ar";s:3:"295";s:3:" by";s:3:"296";s:3:" kr";s:3:"297";s:3:" mi";s:3:"298";s:3:"arb";s:3:"299";}s:7:"tagalog";a:300:{s:3:"ng ";s:1:"0";s:3:"ang";s:1:"1";s:3:" na";s:1:"2";s:3:" sa";s:1:"3";s:3:"an ";s:1:"4";s:3:"nan";s:1:"5";s:3:"sa ";s:1:"6";s:3:"na ";s:1:"7";s:3:" ma";s:1:"8";s:3:" ca";s:1:"9";s:3:"ay ";s:2:"10";s:3:"n g";s:2:"11";s:3:" an";s:2:"12";s:3:"ong";s:2:"13";s:3:" ga";s:2:"14";s:3:"at ";s:2:"15";s:3:" pa";s:2:"16";s:3:"ala";s:2:"17";s:3:" si";s:2:"18";s:3:"a n";s:2:"19";s:3:"ga ";s:2:"20";s:3:"g n";s:2:"21";s:3:"g m";s:2:"22";s:3:"ito";s:2:"23";s:3:"g c";s:2:"24";s:3:"man";s:2:"25";s:3:"san";s:2:"26";s:3:"g s";s:2:"27";s:3:"ing";s:2:"28";s:3:"to ";s:2:"29";s:3:"ila";s:2:"30";s:3:"ina";s:2:"31";s:3:" di";s:2:"32";s:3:" ta";s:2:"33";s:3:"aga";s:2:"34";s:3:"iya";s:2:"35";s:3:"aca";s:2:"36";s:3:"g t";s:2:"37";s:3:" at";s:2:"38";s:3:"aya";s:2:"39";s:3:"ama";s:2:"40";s:3:"lan";s:2:"41";s:3:"a a";s:2:"42";s:3:"qui";s:2:"43";s:3:"a c";s:2:"44";s:3:"a s";s:2:"45";s:3:"nag";s:2:"46";s:3:" ba";s:2:"47";s:3:"g i";s:2:"48";s:3:"tan";s:2:"49";s:3:"'t ";s:2:"50";s:3:" cu";s:2:"51";s:3:"aua";s:2:"52";s:3:"g p";s:2:"53";s:3:" ni";s:2:"54";s:3:"os ";s:2:"55";s:3:"'y ";s:2:"56";s:3:"a m";s:2:"57";s:3:" n ";s:2:"58";s:3:"la ";s:2:"59";s:3:" la";s:2:"60";s:3:"o n";s:2:"61";s:3:"yan";s:2:"62";s:3:" ay";s:2:"63";s:3:"usa";s:2:"64";s:3:"cay";s:2:"65";s:3:"on ";s:2:"66";s:3:"ya ";s:2:"67";s:3:" it";s:2:"68";s:3:"al ";s:2:"69";s:3:"apa";s:2:"70";s:3:"ata";s:2:"71";s:3:"t n";s:2:"72";s:3:"uan";s:2:"73";s:3:"aha";s:2:"74";s:3:"asa";s:2:"75";s:3:"pag";s:2:"76";s:3:" gu";s:2:"77";s:3:"g l";s:2:"78";s:3:"di ";s:2:"79";s:3:"mag";s:2:"80";s:3:"aba";s:2:"81";s:3:"g a";s:2:"82";s:3:"ara";s:2:"83";s:3:"a p";s:2:"84";s:3:"in ";s:2:"85";s:3:"ana";s:2:"86";s:3:"it ";s:2:"87";s:3:"si ";s:2:"88";s:3:"cus";s:2:"89";s:3:"g b";s:2:"90";s:3:"uin";s:2:"91";s:3:"a t";s:2:"92";s:3:"as ";s:2:"93";s:3:"n n";s:2:"94";s:3:"hin";s:2:"95";s:3:" hi";s:2:"96";s:3:"a't";s:2:"97";s:3:"ali";s:2:"98";s:3:" bu";s:2:"99";s:3:"gan";s:3:"100";s:3:"uma";s:3:"101";s:3:"a d";s:3:"102";s:3:"agc";s:3:"103";s:3:"aqu";s:3:"104";s:3:"g d";s:3:"105";s:3:" tu";s:3:"106";s:3:"aon";s:3:"107";s:3:"ari";s:3:"108";s:3:"cas";s:3:"109";s:3:"i n";s:3:"110";s:3:"niy";s:3:"111";s:3:"pin";s:3:"112";s:3:"a i";s:3:"113";s:3:"gca";s:3:"114";s:3:"siy";s:3:"115";s:3:"a'y";s:3:"116";s:3:"yao";s:3:"117";s:3:"ag ";s:3:"118";s:3:"ca ";s:3:"119";s:3:"han";s:3:"120";s:3:"ili";s:3:"121";s:3:"pan";s:3:"122";s:3:"sin";s:3:"123";s:3:"ual";s:3:"124";s:3:"n s";s:3:"125";s:3:"nam";s:3:"126";s:3:" lu";s:3:"127";s:3:"can";s:3:"128";s:3:"dit";s:3:"129";s:3:"gui";s:3:"130";s:3:"y n";s:3:"131";s:3:"gal";s:3:"132";s:3:"hat";s:3:"133";s:3:"nal";s:3:"134";s:3:" is";s:3:"135";s:3:"bag";s:3:"136";s:3:"fra";s:3:"137";s:3:" fr";s:3:"138";s:3:" su";s:3:"139";s:3:"a l";s:3:"140";s:3:" co";s:3:"141";s:3:"ani";s:3:"142";s:3:" bi";s:3:"143";s:3:" da";s:3:"144";s:3:"alo";s:3:"145";s:3:"isa";s:3:"146";s:3:"ita";s:3:"147";s:3:"may";s:3:"148";s:3:"o s";s:3:"149";s:3:"sil";s:3:"150";s:3:"una";s:3:"151";s:3:" in";s:3:"152";s:3:" pi";s:3:"153";s:3:"l n";s:3:"154";s:3:"nil";s:3:"155";s:3:"o a";s:3:"156";s:3:"pat";s:3:"157";s:3:"sac";s:3:"158";s:3:"t s";s:3:"159";s:3:" ua";s:3:"160";s:3:"agu";s:3:"161";s:3:"ail";s:3:"162";s:3:"bin";s:3:"163";s:3:"dal";s:3:"164";s:3:"g h";s:3:"165";s:3:"ndi";s:3:"166";s:3:"oon";s:3:"167";s:3:"ua ";s:3:"168";s:3:" ha";s:3:"169";s:3:"ind";s:3:"170";s:3:"ran";s:3:"171";s:3:"s n";s:3:"172";s:3:"tin";s:3:"173";s:3:"ulo";s:3:"174";s:3:"eng";s:3:"175";s:3:"g f";s:3:"176";s:3:"ini";s:3:"177";s:3:"lah";s:3:"178";s:3:"lo ";s:3:"179";s:3:"rai";s:3:"180";s:3:"rin";s:3:"181";s:3:"ton";s:3:"182";s:3:"g u";s:3:"183";s:3:"inu";s:3:"184";s:3:"lon";s:3:"185";s:3:"o'y";s:3:"186";s:3:"t a";s:3:"187";s:3:" ar";s:3:"188";s:3:"a b";s:3:"189";s:3:"ad ";s:3:"190";s:3:"bay";s:3:"191";s:3:"cal";s:3:"192";s:3:"gya";s:3:"193";s:3:"ile";s:3:"194";s:3:"mat";s:3:"195";s:3:"n a";s:3:"196";s:3:"pau";s:3:"197";s:3:"ra ";s:3:"198";s:3:"tay";s:3:"199";s:3:"y m";s:3:"200";s:3:"ant";s:3:"201";s:3:"ban";s:3:"202";s:3:"i m";s:3:"203";s:3:"nas";s:3:"204";s:3:"nay";s:3:"205";s:3:"no ";s:3:"206";s:3:"sti";s:3:"207";s:3:" ti";s:3:"208";s:3:"ags";s:3:"209";s:3:"g g";s:3:"210";s:3:"ta ";s:3:"211";s:3:"uit";s:3:"212";s:3:"uno";s:3:"213";s:3:" ib";s:3:"214";s:3:" ya";s:3:"215";s:3:"a u";s:3:"216";s:3:"abi";s:3:"217";s:3:"ati";s:3:"218";s:3:"cap";s:3:"219";s:3:"ig ";s:3:"220";s:3:"is ";s:3:"221";s:3:"la'";s:3:"222";s:3:" do";s:3:"223";s:3:" pu";s:3:"224";s:3:"api";s:3:"225";s:3:"ayo";s:3:"226";s:3:"gos";s:3:"227";s:3:"gul";s:3:"228";s:3:"lal";s:3:"229";s:3:"tag";s:3:"230";s:3:"til";s:3:"231";s:3:"tun";s:3:"232";s:3:"y c";s:3:"233";s:3:"y s";s:3:"234";s:3:"yon";s:3:"235";s:3:"ano";s:3:"236";s:3:"bur";s:3:"237";s:3:"iba";s:3:"238";s:3:"isi";s:3:"239";s:3:"lam";s:3:"240";s:3:"nac";s:3:"241";s:3:"nat";s:3:"242";s:3:"ni ";s:3:"243";s:3:"nto";s:3:"244";s:3:"od ";s:3:"245";s:3:"pa ";s:3:"246";s:3:"rgo";s:3:"247";s:3:"urg";s:3:"248";s:3:" m ";s:3:"249";s:3:"adr";s:3:"250";s:3:"ast";s:3:"251";s:3:"cag";s:3:"252";s:3:"gay";s:3:"253";s:3:"gsi";s:3:"254";s:3:"i p";s:3:"255";s:3:"ino";s:3:"256";s:3:"len";s:3:"257";s:3:"lin";s:3:"258";s:3:"m g";s:3:"259";s:3:"mar";s:3:"260";s:3:"nah";s:3:"261";s:3:"to'";s:3:"262";s:3:" de";s:3:"263";s:3:"a h";s:3:"264";s:3:"cat";s:3:"265";s:3:"cau";s:3:"266";s:3:"con";s:3:"267";s:3:"iqu";s:3:"268";s:3:"lac";s:3:"269";s:3:"mab";s:3:"270";s:3:"min";s:3:"271";s:3:"og ";s:3:"272";s:3:"par";s:3:"273";s:3:"sal";s:3:"274";s:3:" za";s:3:"275";s:3:"ao ";s:3:"276";s:3:"doo";s:3:"277";s:3:"ipi";s:3:"278";s:3:"nod";s:3:"279";s:3:"nte";s:3:"280";s:3:"uha";s:3:"281";s:3:"ula";s:3:"282";s:3:" re";s:3:"283";s:3:"ill";s:3:"284";s:3:"lit";s:3:"285";s:3:"mac";s:3:"286";s:3:"nit";s:3:"287";s:3:"o't";s:3:"288";s:3:"or ";s:3:"289";s:3:"ora";s:3:"290";s:3:"sum";s:3:"291";s:3:"y p";s:3:"292";s:3:" al";s:3:"293";s:3:" mi";s:3:"294";s:3:" um";s:3:"295";s:3:"aco";s:3:"296";s:3:"ada";s:3:"297";s:3:"agd";s:3:"298";s:3:"cab";s:3:"299";}s:7:"turkish";a:300:{s:3:"lar";s:1:"0";s:3:"en ";s:1:"1";s:3:"ler";s:1:"2";s:3:"an ";s:1:"3";s:3:"in ";s:1:"4";s:3:" bi";s:1:"5";s:3:" ya";s:1:"6";s:3:"eri";s:1:"7";s:3:"de ";s:1:"8";s:3:" ka";s:1:"9";s:3:"ir ";s:2:"10";s:4:"arı";s:2:"11";s:3:" ba";s:2:"12";s:3:" de";s:2:"13";s:3:" ha";s:2:"14";s:4:"ın ";s:2:"15";s:3:"ara";s:2:"16";s:3:"bir";s:2:"17";s:3:" ve";s:2:"18";s:3:" sa";s:2:"19";s:3:"ile";s:2:"20";s:3:"le ";s:2:"21";s:3:"nde";s:2:"22";s:3:"da ";s:2:"23";s:3:" bu";s:2:"24";s:3:"ana";s:2:"25";s:3:"ini";s:2:"26";s:5:"ını";s:2:"27";s:3:"er ";s:2:"28";s:3:"ve ";s:2:"29";s:4:" yı";s:2:"30";s:3:"lma";s:2:"31";s:4:"yıl";s:2:"32";s:3:" ol";s:2:"33";s:3:"ar ";s:2:"34";s:3:"n b";s:2:"35";s:3:"nda";s:2:"36";s:3:"aya";s:2:"37";s:3:"li ";s:2:"38";s:4:"ası";s:2:"39";s:3:" ge";s:2:"40";s:3:"ind";s:2:"41";s:3:"n k";s:2:"42";s:3:"esi";s:2:"43";s:3:"lan";s:2:"44";s:3:"nla";s:2:"45";s:3:"ak ";s:2:"46";s:4:"anı";s:2:"47";s:3:"eni";s:2:"48";s:3:"ni ";s:2:"49";s:4:"nı ";s:2:"50";s:4:"rın";s:2:"51";s:3:"san";s:2:"52";s:3:" ko";s:2:"53";s:3:" ye";s:2:"54";s:3:"maz";s:2:"55";s:4:"baş";s:2:"56";s:3:"ili";s:2:"57";s:3:"rin";s:2:"58";s:4:"alı";s:2:"59";s:3:"az ";s:2:"60";s:3:"hal";s:2:"61";s:4:"ınd";s:2:"62";s:3:" da";s:2:"63";s:4:" gü";s:2:"64";s:3:"ele";s:2:"65";s:4:"ılm";s:2:"66";s:6:"ığı";s:2:"67";s:3:"eki";s:2:"68";s:4:"gün";s:2:"69";s:3:"i b";s:2:"70";s:4:"içi";s:2:"71";s:3:"den";s:2:"72";s:3:"kar";s:2:"73";s:3:"si ";s:2:"74";s:3:" il";s:2:"75";s:3:"e y";s:2:"76";s:3:"na ";s:2:"77";s:3:"yor";s:2:"78";s:3:"ek ";s:2:"79";s:3:"n s";s:2:"80";s:4:" iç";s:2:"81";s:3:"bu ";s:2:"82";s:3:"e b";s:2:"83";s:3:"im ";s:2:"84";s:3:"ki ";s:2:"85";s:3:"len";s:2:"86";s:3:"ri ";s:2:"87";s:4:"sın";s:2:"88";s:3:" so";s:2:"89";s:4:"ün ";s:2:"90";s:3:" ta";s:2:"91";s:3:"nin";s:2:"92";s:4:"iği";s:2:"93";s:3:"tan";s:2:"94";s:3:"yan";s:2:"95";s:3:" si";s:2:"96";s:3:"nat";s:2:"97";s:4:"nın";s:2:"98";s:3:"kan";s:2:"99";s:4:"rı ";s:3:"100";s:4:"çin";s:3:"101";s:5:"ğı ";s:3:"102";s:3:"eli";s:3:"103";s:3:"n a";s:3:"104";s:4:"ır ";s:3:"105";s:3:" an";s:3:"106";s:3:"ine";s:3:"107";s:3:"n y";s:3:"108";s:3:"ola";s:3:"109";s:3:" ar";s:3:"110";s:3:"al ";s:3:"111";s:3:"e s";s:3:"112";s:3:"lik";s:3:"113";s:3:"n d";s:3:"114";s:3:"sin";s:3:"115";s:3:" al";s:3:"116";s:4:" dü";s:3:"117";s:3:"anl";s:3:"118";s:3:"ne ";s:3:"119";s:3:"ya ";s:3:"120";s:4:"ım ";s:3:"121";s:4:"ına";s:3:"122";s:3:" be";s:3:"123";s:3:"ada";s:3:"124";s:3:"ala";s:3:"125";s:3:"ama";s:3:"126";s:3:"ilm";s:3:"127";s:3:"or ";s:3:"128";s:4:"sı ";s:3:"129";s:3:"yen";s:3:"130";s:3:" me";s:3:"131";s:4:"atı";s:3:"132";s:3:"di ";s:3:"133";s:3:"eti";s:3:"134";s:3:"ken";s:3:"135";s:3:"la ";s:3:"136";s:4:"lı ";s:3:"137";s:3:"oru";s:3:"138";s:4:" gö";s:3:"139";s:3:" in";s:3:"140";s:3:"and";s:3:"141";s:3:"e d";s:3:"142";s:3:"men";s:3:"143";s:3:"un ";s:3:"144";s:4:"öne";s:3:"145";s:3:"a d";s:3:"146";s:3:"at ";s:3:"147";s:3:"e a";s:3:"148";s:3:"e g";s:3:"149";s:3:"yar";s:3:"150";s:3:" ku";s:3:"151";s:4:"ayı";s:3:"152";s:3:"dan";s:3:"153";s:3:"edi";s:3:"154";s:3:"iri";s:3:"155";s:5:"ünü";s:3:"156";s:4:"ği ";s:3:"157";s:5:"ılı";s:3:"158";s:3:"eme";s:3:"159";s:4:"eği";s:3:"160";s:3:"i k";s:3:"161";s:3:"i y";s:3:"162";s:4:"ıla";s:3:"163";s:4:" ça";s:3:"164";s:3:"a y";s:3:"165";s:3:"alk";s:3:"166";s:4:"dı ";s:3:"167";s:3:"ede";s:3:"168";s:3:"el ";s:3:"169";s:4:"ndı";s:3:"170";s:3:"ra ";s:3:"171";s:4:"üne";s:3:"172";s:4:" sü";s:3:"173";s:4:"dır";s:3:"174";s:3:"e k";s:3:"175";s:3:"ere";s:3:"176";s:3:"ik ";s:3:"177";s:3:"imi";s:3:"178";s:4:"işi";s:3:"179";s:3:"mas";s:3:"180";s:3:"n h";s:3:"181";s:4:"sür";s:3:"182";s:3:"yle";s:3:"183";s:3:" ad";s:3:"184";s:3:" fi";s:3:"185";s:3:" gi";s:3:"186";s:3:" se";s:3:"187";s:3:"a k";s:3:"188";s:3:"arl";s:3:"189";s:5:"aşı";s:3:"190";s:3:"iyo";s:3:"191";s:3:"kla";s:3:"192";s:5:"lığ";s:3:"193";s:3:"nem";s:3:"194";s:3:"ney";s:3:"195";s:3:"rme";s:3:"196";s:3:"ste";s:3:"197";s:4:"tı ";s:3:"198";s:3:"unl";s:3:"199";s:3:"ver";s:3:"200";s:4:" sı";s:3:"201";s:3:" te";s:3:"202";s:3:" to";s:3:"203";s:3:"a s";s:3:"204";s:4:"aşk";s:3:"205";s:3:"ekl";s:3:"206";s:3:"end";s:3:"207";s:3:"kal";s:3:"208";s:4:"liğ";s:3:"209";s:3:"min";s:3:"210";s:4:"tır";s:3:"211";s:3:"ulu";s:3:"212";s:3:"unu";s:3:"213";s:3:"yap";s:3:"214";s:3:"ye ";s:3:"215";s:4:"ı i";s:3:"216";s:4:"şka";s:3:"217";s:5:"ştı";s:3:"218";s:4:" bü";s:3:"219";s:3:" ke";s:3:"220";s:3:" ki";s:3:"221";s:3:"ard";s:3:"222";s:3:"art";s:3:"223";s:4:"aşa";s:3:"224";s:3:"n i";s:3:"225";s:3:"ndi";s:3:"226";s:3:"ti ";s:3:"227";s:3:"top";s:3:"228";s:4:"ı b";s:3:"229";s:3:" va";s:3:"230";s:4:" ön";s:3:"231";s:3:"aki";s:3:"232";s:3:"cak";s:3:"233";s:3:"ey ";s:3:"234";s:3:"fil";s:3:"235";s:3:"isi";s:3:"236";s:3:"kle";s:3:"237";s:3:"kur";s:3:"238";s:3:"man";s:3:"239";s:3:"nce";s:3:"240";s:3:"nle";s:3:"241";s:3:"nun";s:3:"242";s:3:"rak";s:3:"243";s:4:"ık ";s:3:"244";s:3:" en";s:3:"245";s:3:" yo";s:3:"246";s:3:"a g";s:3:"247";s:3:"lis";s:3:"248";s:3:"mak";s:3:"249";s:3:"n g";s:3:"250";s:3:"tir";s:3:"251";s:3:"yas";s:3:"252";s:4:" iş";s:3:"253";s:4:" yö";s:3:"254";s:3:"ale";s:3:"255";s:3:"bil";s:3:"256";s:3:"bul";s:3:"257";s:3:"et ";s:3:"258";s:3:"i d";s:3:"259";s:3:"iye";s:3:"260";s:3:"kil";s:3:"261";s:3:"ma ";s:3:"262";s:3:"n e";s:3:"263";s:3:"n t";s:3:"264";s:3:"nu ";s:3:"265";s:3:"olu";s:3:"266";s:3:"rla";s:3:"267";s:3:"te ";s:3:"268";s:4:"yön";s:3:"269";s:5:"çık";s:3:"270";s:3:" ay";s:3:"271";s:4:" mü";s:3:"272";s:4:" ço";s:3:"273";s:5:" çı";s:3:"274";s:3:"a a";s:3:"275";s:3:"a b";s:3:"276";s:3:"ata";s:3:"277";s:3:"der";s:3:"278";s:3:"gel";s:3:"279";s:3:"i g";s:3:"280";s:3:"i i";s:3:"281";s:3:"ill";s:3:"282";s:3:"ist";s:3:"283";s:4:"ldı";s:3:"284";s:3:"lu ";s:3:"285";s:3:"mek";s:3:"286";s:3:"mle";s:3:"287";s:4:"n ç";s:3:"288";s:3:"onu";s:3:"289";s:3:"opl";s:3:"290";s:3:"ran";s:3:"291";s:3:"rat";s:3:"292";s:4:"rdı";s:3:"293";s:3:"rke";s:3:"294";s:3:"siy";s:3:"295";s:3:"son";s:3:"296";s:3:"ta ";s:3:"297";s:5:"tçı";s:3:"298";s:4:"tın";s:3:"299";}s:9:"ukrainian";a:300:{s:5:" на";s:1:"0";s:5:" за";s:1:"1";s:6:"ння";s:1:"2";s:5:"ня ";s:1:"3";s:5:"на ";s:1:"4";s:5:" пр";s:1:"5";s:6:"ого";s:1:"6";s:5:"го ";s:1:"7";s:6:"ськ";s:1:"8";s:5:" по";s:1:"9";s:4:" у ";s:2:"10";s:6:"від";s:2:"11";s:6:"ере";s:2:"12";s:5:" мі";s:2:"13";s:5:" не";s:2:"14";s:5:"их ";s:2:"15";s:5:"ть ";s:2:"16";s:6:"пер";s:2:"17";s:5:" ві";s:2:"18";s:5:"ів ";s:2:"19";s:5:" пе";s:2:"20";s:5:" що";s:2:"21";s:6:"льн";s:2:"22";s:5:"ми ";s:2:"23";s:5:"ні ";s:2:"24";s:5:"не ";s:2:"25";s:5:"ти ";s:2:"26";s:6:"ати";s:2:"27";s:6:"енн";s:2:"28";s:6:"міс";s:2:"29";s:6:"пра";s:2:"30";s:6:"ува";s:2:"31";s:6:"ник";s:2:"32";s:6:"про";s:2:"33";s:6:"рав";s:2:"34";s:6:"івн";s:2:"35";s:5:" та";s:2:"36";s:6:"буд";s:2:"37";s:6:"влі";s:2:"38";s:6:"рів";s:2:"39";s:5:" ко";s:2:"40";s:5:" рі";s:2:"41";s:6:"аль";s:2:"42";s:5:"но ";s:2:"43";s:6:"ому";s:2:"44";s:5:"що ";s:2:"45";s:5:" ви";s:2:"46";s:5:"му ";s:2:"47";s:6:"рев";s:2:"48";s:5:"ся ";s:2:"49";s:6:"інн";s:2:"50";s:5:" до";s:2:"51";s:5:" уп";s:2:"52";s:6:"авл";s:2:"53";s:6:"анн";s:2:"54";s:6:"ком";s:2:"55";s:5:"ли ";s:2:"56";s:6:"лін";s:2:"57";s:6:"ног";s:2:"58";s:6:"упр";s:2:"59";s:5:" бу";s:2:"60";s:4:" з ";s:2:"61";s:5:" ро";s:2:"62";s:5:"за ";s:2:"63";s:5:"и н";s:2:"64";s:6:"нов";s:2:"65";s:6:"оро";s:2:"66";s:6:"ост";s:2:"67";s:6:"ста";s:2:"68";s:5:"ті ";s:2:"69";s:6:"ють";s:2:"70";s:5:" мо";s:2:"71";s:5:" ні";s:2:"72";s:5:" як";s:2:"73";s:6:"бор";s:2:"74";s:5:"ва ";s:2:"75";s:6:"ван";s:2:"76";s:6:"ень";s:2:"77";s:5:"и п";s:2:"78";s:5:"нь ";s:2:"79";s:6:"ові";s:2:"80";s:6:"рон";s:2:"81";s:6:"сті";s:2:"82";s:5:"та ";s:2:"83";s:5:"у в";s:2:"84";s:6:"ько";s:2:"85";s:6:"іст";s:2:"86";s:4:" в ";s:2:"87";s:5:" ре";s:2:"88";s:5:"до ";s:2:"89";s:5:"е п";s:2:"90";s:6:"заб";s:2:"91";s:5:"ий ";s:2:"92";s:6:"нсь";s:2:"93";s:5:"о в";s:2:"94";s:5:"о п";s:2:"95";s:6:"при";s:2:"96";s:5:"і п";s:2:"97";s:5:" ку";s:2:"98";s:5:" пі";s:2:"99";s:5:" сп";s:3:"100";s:5:"а п";s:3:"101";s:6:"або";s:3:"102";s:6:"анс";s:3:"103";s:6:"аці";s:3:"104";s:6:"ват";s:3:"105";s:6:"вни";s:3:"106";s:5:"и в";s:3:"107";s:6:"ими";s:3:"108";s:5:"ка ";s:3:"109";s:6:"нен";s:3:"110";s:6:"ніч";s:3:"111";s:6:"она";s:3:"112";s:5:"ої ";s:3:"113";s:6:"пов";s:3:"114";s:6:"ьки";s:3:"115";s:6:"ьно";s:3:"116";s:6:"ізн";s:3:"117";s:6:"ічн";s:3:"118";s:5:" ав";s:3:"119";s:5:" ма";s:3:"120";s:5:" ор";s:3:"121";s:5:" су";s:3:"122";s:5:" чи";s:3:"123";s:5:" ін";s:3:"124";s:5:"а з";s:3:"125";s:5:"ам ";s:3:"126";s:5:"ає ";s:3:"127";s:6:"вне";s:3:"128";s:6:"вто";s:3:"129";s:6:"дом";s:3:"130";s:6:"ент";s:3:"131";s:6:"жит";s:3:"132";s:6:"зни";s:3:"133";s:5:"им ";s:3:"134";s:6:"итл";s:3:"135";s:5:"ла ";s:3:"136";s:6:"них";s:3:"137";s:6:"ниц";s:3:"138";s:6:"ова";s:3:"139";s:6:"ови";s:3:"140";s:5:"ом ";s:3:"141";s:6:"пор";s:3:"142";s:6:"тьс";s:3:"143";s:5:"у р";s:3:"144";s:6:"ься";s:3:"145";s:6:"ідо";s:3:"146";s:6:"іль";s:3:"147";s:6:"ісь";s:3:"148";s:5:" ва";s:3:"149";s:5:" ді";s:3:"150";s:5:" жи";s:3:"151";s:5:" че";s:3:"152";s:4:" і ";s:3:"153";s:5:"а в";s:3:"154";s:5:"а н";s:3:"155";s:6:"али";s:3:"156";s:6:"вез";s:3:"157";s:6:"вно";s:3:"158";s:6:"еве";s:3:"159";s:6:"езе";s:3:"160";s:6:"зен";s:3:"161";s:6:"ицт";s:3:"162";s:5:"ки ";s:3:"163";s:6:"ких";s:3:"164";s:6:"кон";s:3:"165";s:5:"ку ";s:3:"166";s:6:"лас";s:3:"167";s:5:"ля ";s:3:"168";s:6:"мож";s:3:"169";s:6:"нач";s:3:"170";s:6:"ним";s:3:"171";s:6:"ної";s:3:"172";s:5:"о б";s:3:"173";s:6:"ову";s:3:"174";s:6:"оди";s:3:"175";s:5:"ою ";s:3:"176";s:5:"ро ";s:3:"177";s:6:"рок";s:3:"178";s:6:"сно";s:3:"179";s:6:"спо";s:3:"180";s:6:"так";s:3:"181";s:6:"тва";s:3:"182";s:5:"ту ";s:3:"183";s:5:"у п";s:3:"184";s:6:"цтв";s:3:"185";s:6:"ьни";s:3:"186";s:5:"я з";s:3:"187";s:5:"і м";s:3:"188";s:5:"ії ";s:3:"189";s:5:" вс";s:3:"190";s:5:" гр";s:3:"191";s:5:" де";s:3:"192";s:5:" но";s:3:"193";s:5:" па";s:3:"194";s:5:" се";s:3:"195";s:5:" ук";s:3:"196";s:5:" їх";s:3:"197";s:5:"а о";s:3:"198";s:6:"авт";s:3:"199";s:6:"аст";s:3:"200";s:6:"ают";s:3:"201";s:6:"вар";s:3:"202";s:6:"ден";s:3:"203";s:5:"ди ";s:3:"204";s:5:"ду ";s:3:"205";s:6:"зна";s:3:"206";s:5:"и з";s:3:"207";s:6:"ико";s:3:"208";s:6:"ися";s:3:"209";s:6:"ити";s:3:"210";s:6:"ког";s:3:"211";s:6:"мен";s:3:"212";s:6:"ном";s:3:"213";s:5:"ну ";s:3:"214";s:5:"о н";s:3:"215";s:5:"о с";s:3:"216";s:6:"обу";s:3:"217";s:6:"ово";s:3:"218";s:6:"пла";s:3:"219";s:6:"ран";s:3:"220";s:6:"рив";s:3:"221";s:6:"роб";s:3:"222";s:6:"ска";s:3:"223";s:6:"тан";s:3:"224";s:6:"тим";s:3:"225";s:6:"тис";s:3:"226";s:5:"то ";s:3:"227";s:6:"тра";s:3:"228";s:6:"удо";s:3:"229";s:6:"чин";s:3:"230";s:6:"чни";s:3:"231";s:5:"і в";s:3:"232";s:5:"ію ";s:3:"233";s:4:" а ";s:3:"234";s:5:" во";s:3:"235";s:5:" да";s:3:"236";s:5:" кв";s:3:"237";s:5:" ме";s:3:"238";s:5:" об";s:3:"239";s:5:" ск";s:3:"240";s:5:" ти";s:3:"241";s:5:" фі";s:3:"242";s:4:" є ";s:3:"243";s:5:"а р";s:3:"244";s:5:"а с";s:3:"245";s:5:"а у";s:3:"246";s:5:"ак ";s:3:"247";s:6:"ані";s:3:"248";s:6:"арт";s:3:"249";s:6:"асн";s:3:"250";s:5:"в у";s:3:"251";s:6:"вик";s:3:"252";s:6:"віз";s:3:"253";s:6:"дов";s:3:"254";s:6:"дпо";s:3:"255";s:6:"дів";s:3:"256";s:6:"еві";s:3:"257";s:6:"енс";s:3:"258";s:5:"же ";s:3:"259";s:5:"и м";s:3:"260";s:5:"и с";s:3:"261";s:6:"ика";s:3:"262";s:6:"ичн";s:3:"263";s:5:"кі ";s:3:"264";s:6:"ків";s:3:"265";s:6:"між";s:3:"266";s:6:"нан";s:3:"267";s:6:"нос";s:3:"268";s:5:"о у";s:3:"269";s:6:"обл";s:3:"270";s:6:"одн";s:3:"271";s:5:"ок ";s:3:"272";s:6:"оло";s:3:"273";s:6:"отр";s:3:"274";s:6:"рен";s:3:"275";s:6:"рим";s:3:"276";s:6:"роз";s:3:"277";s:5:"сь ";s:3:"278";s:5:"сі ";s:3:"279";s:6:"тла";s:3:"280";s:6:"тів";s:3:"281";s:5:"у з";s:3:"282";s:6:"уго";s:3:"283";s:6:"уді";s:3:"284";s:5:"чи ";s:3:"285";s:5:"ше ";s:3:"286";s:5:"я н";s:3:"287";s:5:"я у";s:3:"288";s:6:"ідп";s:3:"289";s:5:"ій ";s:3:"290";s:6:"іна";s:3:"291";s:5:"ія ";s:3:"292";s:5:" ка";s:3:"293";s:5:" ни";s:3:"294";s:5:" ос";s:3:"295";s:5:" си";s:3:"296";s:5:" то";s:3:"297";s:5:" тр";s:3:"298";s:5:" уг";s:3:"299";}s:4:"urdu";a:300:{s:5:"یں ";s:1:"0";s:5:" کی";s:1:"1";s:5:"کے ";s:1:"2";s:5:" کے";s:1:"3";s:5:"نے ";s:1:"4";s:5:" کہ";s:1:"5";s:5:"ے ک";s:1:"6";s:5:"کی ";s:1:"7";s:6:"میں";s:1:"8";s:5:" می";s:1:"9";s:5:"ہے ";s:2:"10";s:5:"وں ";s:2:"11";s:5:"کہ ";s:2:"12";s:5:" ہے";s:2:"13";s:5:"ان ";s:2:"14";s:6:"ہیں";s:2:"15";s:5:"ور ";s:2:"16";s:5:" کو";s:2:"17";s:5:"یا ";s:2:"18";s:5:" ان";s:2:"19";s:5:" نے";s:2:"20";s:5:"سے ";s:2:"21";s:5:" سے";s:2:"22";s:5:" کر";s:2:"23";s:6:"ستا";s:2:"24";s:5:" او";s:2:"25";s:6:"اور";s:2:"26";s:6:"تان";s:2:"27";s:5:"ر ک";s:2:"28";s:5:"ی ک";s:2:"29";s:5:" اس";s:2:"30";s:5:"ے ا";s:2:"31";s:5:" پا";s:2:"32";s:5:" ہو";s:2:"33";s:5:" پر";s:2:"34";s:5:"رف ";s:2:"35";s:5:" کا";s:2:"36";s:5:"ا ک";s:2:"37";s:5:"ی ا";s:2:"38";s:5:" ہی";s:2:"39";s:5:"در ";s:2:"40";s:5:"کو ";s:2:"41";s:5:" ای";s:2:"42";s:5:"ں ک";s:2:"43";s:5:" مش";s:2:"44";s:5:" مل";s:2:"45";s:5:"ات ";s:2:"46";s:6:"صدر";s:2:"47";s:6:"اکس";s:2:"48";s:6:"شرف";s:2:"49";s:6:"مشر";s:2:"50";s:6:"پاک";s:2:"51";s:6:"کست";s:2:"52";s:5:"ی م";s:2:"53";s:5:" دی";s:2:"54";s:5:" صد";s:2:"55";s:5:" یہ";s:2:"56";s:5:"ا ہ";s:2:"57";s:5:"ن ک";s:2:"58";s:6:"وال";s:2:"59";s:5:"یہ ";s:2:"60";s:5:"ے و";s:2:"61";s:5:" بھ";s:2:"62";s:5:" دو";s:2:"63";s:5:"اس ";s:2:"64";s:5:"ر ا";s:2:"65";s:6:"نہی";s:2:"66";s:5:"کا ";s:2:"67";s:5:"ے س";s:2:"68";s:5:"ئی ";s:2:"69";s:5:"ہ ا";s:2:"70";s:5:"یت ";s:2:"71";s:5:"ے ہ";s:2:"72";s:5:"ت ک";s:2:"73";s:5:" سا";s:2:"74";s:5:"لے ";s:2:"75";s:5:"ہا ";s:2:"76";s:5:"ے ب";s:2:"77";s:5:" وا";s:2:"78";s:5:"ار ";s:2:"79";s:5:"نی ";s:2:"80";s:6:"کہا";s:2:"81";s:5:"ی ہ";s:2:"82";s:5:"ے م";s:2:"83";s:5:" سی";s:2:"84";s:5:" لی";s:2:"85";s:6:"انہ";s:2:"86";s:6:"انی";s:2:"87";s:5:"ر م";s:2:"88";s:5:"ر پ";s:2:"89";s:6:"ریت";s:2:"90";s:5:"ن م";s:2:"91";s:5:"ھا ";s:2:"92";s:5:"یر ";s:2:"93";s:5:" جا";s:2:"94";s:5:" جن";s:2:"95";s:5:"ئے ";s:2:"96";s:5:"پر ";s:2:"97";s:5:"ں ن";s:2:"98";s:5:"ہ ک";s:2:"99";s:5:"ی و";s:3:"100";s:5:"ے د";s:3:"101";s:5:" تو";s:3:"102";s:5:" تھ";s:3:"103";s:5:" گی";s:3:"104";s:6:"ایک";s:3:"105";s:5:"ل ک";s:3:"106";s:5:"نا ";s:3:"107";s:5:"کر ";s:3:"108";s:5:"ں م";s:3:"109";s:5:"یک ";s:3:"110";s:5:" با";s:3:"111";s:5:"ا ت";s:3:"112";s:5:"دی ";s:3:"113";s:5:"ن س";s:3:"114";s:6:"کیا";s:3:"115";s:6:"یوں";s:3:"116";s:5:"ے ج";s:3:"117";s:5:"ال ";s:3:"118";s:5:"تو ";s:3:"119";s:5:"ں ا";s:3:"120";s:5:"ے پ";s:3:"121";s:5:" چا";s:3:"122";s:5:"ام ";s:3:"123";s:6:"بھی";s:3:"124";s:5:"تی ";s:3:"125";s:5:"تے ";s:3:"126";s:6:"دوس";s:3:"127";s:5:"س ک";s:3:"128";s:6:"ملک";s:3:"129";s:5:"ن ا";s:3:"130";s:6:"ہور";s:3:"131";s:5:"یے ";s:3:"132";s:5:" مو";s:3:"133";s:5:" وک";s:3:"134";s:6:"ائی";s:3:"135";s:6:"ارت";s:3:"136";s:6:"الے";s:3:"137";s:6:"بھا";s:3:"138";s:6:"ردی";s:3:"139";s:5:"ری ";s:3:"140";s:5:"وہ ";s:3:"141";s:6:"ویز";s:3:"142";s:5:"ں د";s:3:"143";s:5:"ھی ";s:3:"144";s:5:"ی س";s:3:"145";s:5:" رہ";s:3:"146";s:5:" من";s:3:"147";s:5:" نہ";s:3:"148";s:5:" ور";s:3:"149";s:5:" وہ";s:3:"150";s:5:" ہن";s:3:"151";s:5:"ا ا";s:3:"152";s:6:"است";s:3:"153";s:5:"ت ا";s:3:"154";s:5:"ت پ";s:3:"155";s:5:"د ک";s:3:"156";s:5:"ز م";s:3:"157";s:5:"ند ";s:3:"158";s:6:"ورد";s:3:"159";s:6:"وکل";s:3:"160";s:5:"گی ";s:3:"161";s:6:"گیا";s:3:"162";s:5:"ہ پ";s:3:"163";s:5:"یز ";s:3:"164";s:5:"ے ت";s:3:"165";s:5:" اع";s:3:"166";s:5:" اپ";s:3:"167";s:5:" جس";s:3:"168";s:5:" جم";s:3:"169";s:5:" جو";s:3:"170";s:5:" سر";s:3:"171";s:6:"اپن";s:3:"172";s:6:"اکث";s:3:"173";s:6:"تھا";s:3:"174";s:6:"ثری";s:3:"175";s:6:"دیا";s:3:"176";s:5:"ر د";s:3:"177";s:5:"رت ";s:3:"178";s:6:"روی";s:3:"179";s:5:"سی ";s:3:"180";s:6:"ملا";s:3:"181";s:6:"ندو";s:3:"182";s:6:"وست";s:3:"183";s:6:"پرو";s:3:"184";s:6:"چاہ";s:3:"185";s:6:"کثر";s:3:"186";s:6:"کلا";s:3:"187";s:5:"ہ ہ";s:3:"188";s:6:"ہند";s:3:"189";s:5:"ہو ";s:3:"190";s:5:"ے ل";s:3:"191";s:5:" اک";s:3:"192";s:5:" دا";s:3:"193";s:5:" سن";s:3:"194";s:5:" وز";s:3:"195";s:5:" پی";s:3:"196";s:5:"ا چ";s:3:"197";s:5:"اء ";s:3:"198";s:6:"اتھ";s:3:"199";s:6:"اقا";s:3:"200";s:5:"اہ ";s:3:"201";s:5:"تھ ";s:3:"202";s:5:"دو ";s:3:"203";s:5:"ر ب";s:3:"204";s:6:"روا";s:3:"205";s:5:"رے ";s:3:"206";s:6:"سات";s:3:"207";s:5:"ف ک";s:3:"208";s:6:"قات";s:3:"209";s:5:"لا ";s:3:"210";s:6:"لاء";s:3:"211";s:5:"م م";s:3:"212";s:5:"م ک";s:3:"213";s:5:"من ";s:3:"214";s:6:"نوں";s:3:"215";s:5:"و ا";s:3:"216";s:6:"کرن";s:3:"217";s:5:"ں ہ";s:3:"218";s:6:"ھار";s:3:"219";s:6:"ہوئ";s:3:"220";s:5:"ہی ";s:3:"221";s:5:"یش ";s:3:"222";s:5:" ام";s:3:"223";s:5:" لا";s:3:"224";s:5:" مس";s:3:"225";s:5:" پو";s:3:"226";s:5:" پہ";s:3:"227";s:6:"انے";s:3:"228";s:5:"ت م";s:3:"229";s:5:"ت ہ";s:3:"230";s:5:"ج ک";s:3:"231";s:6:"دون";s:3:"232";s:6:"زیر";s:3:"233";s:5:"س س";s:3:"234";s:5:"ش ک";s:3:"235";s:5:"ف ن";s:3:"236";s:5:"ل ہ";s:3:"237";s:6:"لاق";s:3:"238";s:5:"لی ";s:3:"239";s:6:"وری";s:3:"240";s:6:"وزی";s:3:"241";s:6:"ونو";s:3:"242";s:6:"کھن";s:3:"243";s:5:"گا ";s:3:"244";s:5:"ں س";s:3:"245";s:5:"ں گ";s:3:"246";s:6:"ھنے";s:3:"247";s:5:"ھے ";s:3:"248";s:5:"ہ ب";s:3:"249";s:5:"ہ ج";s:3:"250";s:5:"ہر ";s:3:"251";s:5:"ی آ";s:3:"252";s:5:"ی پ";s:3:"253";s:5:" حا";s:3:"254";s:5:" وف";s:3:"255";s:5:" گا";s:3:"256";s:5:"ا ج";s:3:"257";s:5:"ا گ";s:3:"258";s:5:"اد ";s:3:"259";s:6:"ادی";s:3:"260";s:6:"اعظ";s:3:"261";s:6:"اہت";s:3:"262";s:5:"جس ";s:3:"263";s:6:"جمہ";s:3:"264";s:5:"جو ";s:3:"265";s:5:"ر س";s:3:"266";s:5:"ر ہ";s:3:"267";s:6:"رنے";s:3:"268";s:5:"س م";s:3:"269";s:5:"سا ";s:3:"270";s:6:"سند";s:3:"271";s:6:"سنگ";s:3:"272";s:5:"ظم ";s:3:"273";s:6:"عظم";s:3:"274";s:5:"ل م";s:3:"275";s:6:"لیے";s:3:"276";s:5:"مل ";s:3:"277";s:6:"موہ";s:3:"278";s:6:"مہو";s:3:"279";s:6:"نگھ";s:3:"280";s:5:"و ص";s:3:"281";s:6:"ورٹ";s:3:"282";s:6:"وہن";s:3:"283";s:5:"کن ";s:3:"284";s:5:"گھ ";s:3:"285";s:5:"گے ";s:3:"286";s:5:"ں ج";s:3:"287";s:5:"ں و";s:3:"288";s:5:"ں ی";s:3:"289";s:5:"ہ د";s:3:"290";s:5:"ہن ";s:3:"291";s:6:"ہوں";s:3:"292";s:5:"ے ح";s:3:"293";s:5:"ے گ";s:3:"294";s:5:"ے ی";s:3:"295";s:5:" اگ";s:3:"296";s:5:" بع";s:3:"297";s:5:" رو";s:3:"298";s:5:" شا";s:3:"299";}s:5:"uzbek";a:300:{s:5:"ан ";s:1:"0";s:6:"ган";s:1:"1";s:6:"лар";s:1:"2";s:5:"га ";s:1:"3";s:5:"нг ";s:1:"4";s:6:"инг";s:1:"5";s:6:"нин";s:1:"6";s:5:"да ";s:1:"7";s:5:"ни ";s:1:"8";s:6:"ида";s:1:"9";s:6:"ари";s:2:"10";s:6:"ига";s:2:"11";s:6:"ини";s:2:"12";s:5:"ар ";s:2:"13";s:5:"ди ";s:2:"14";s:5:" би";s:2:"15";s:6:"ани";s:2:"16";s:5:" бо";s:2:"17";s:6:"дан";s:2:"18";s:6:"лга";s:2:"19";s:5:" ҳа";s:2:"20";s:5:" ва";s:2:"21";s:5:" са";s:2:"22";s:5:"ги ";s:2:"23";s:6:"ила";s:2:"24";s:5:"н б";s:2:"25";s:5:"и б";s:2:"26";s:5:" кў";s:2:"27";s:5:" та";s:2:"28";s:5:"ир ";s:2:"29";s:5:" ма";s:2:"30";s:6:"ага";s:2:"31";s:6:"ала";s:2:"32";s:6:"бир";s:2:"33";s:5:"ри ";s:2:"34";s:6:"тга";s:2:"35";s:6:"лан";s:2:"36";s:6:"лик";s:2:"37";s:5:"а к";s:2:"38";s:6:"аги";s:2:"39";s:6:"ати";s:2:"40";s:5:"та ";s:2:"41";s:6:"ади";s:2:"42";s:6:"даг";s:2:"43";s:6:"рга";s:2:"44";s:5:" йи";s:2:"45";s:5:" ми";s:2:"46";s:5:" па";s:2:"47";s:5:" бў";s:2:"48";s:5:" қа";s:2:"49";s:5:" қи";s:2:"50";s:5:"а б";s:2:"51";s:6:"илл";s:2:"52";s:5:"ли ";s:2:"53";s:6:"аси";s:2:"54";s:5:"и т";s:2:"55";s:5:"ик ";s:2:"56";s:6:"или";s:2:"57";s:6:"лла";s:2:"58";s:6:"ард";s:2:"59";s:6:"вчи";s:2:"60";s:5:"ва ";s:2:"61";s:5:"иб ";s:2:"62";s:6:"ири";s:2:"63";s:6:"лиг";s:2:"64";s:6:"нга";s:2:"65";s:6:"ран";s:2:"66";s:5:" ке";s:2:"67";s:5:" ўз";s:2:"68";s:5:"а с";s:2:"69";s:6:"ахт";s:2:"70";s:6:"бўл";s:2:"71";s:6:"иги";s:2:"72";s:6:"кўр";s:2:"73";s:6:"рда";s:2:"74";s:6:"рни";s:2:"75";s:5:"са ";s:2:"76";s:5:" бе";s:2:"77";s:5:" бу";s:2:"78";s:5:" да";s:2:"79";s:5:" жа";s:2:"80";s:5:"а т";s:2:"81";s:6:"ази";s:2:"82";s:6:"ери";s:2:"83";s:5:"и а";s:2:"84";s:6:"илг";s:2:"85";s:6:"йил";s:2:"86";s:6:"ман";s:2:"87";s:6:"пах";s:2:"88";s:6:"рид";s:2:"89";s:5:"ти ";s:2:"90";s:6:"увч";s:2:"91";s:6:"хта";s:2:"92";s:5:" не";s:2:"93";s:5:" со";s:2:"94";s:5:" уч";s:2:"95";s:6:"айт";s:2:"96";s:6:"лли";s:2:"97";s:6:"тла";s:2:"98";s:5:" ай";s:2:"99";s:5:" фр";s:3:"100";s:5:" эт";s:3:"101";s:5:" ҳо";s:3:"102";s:5:"а қ";s:3:"103";s:6:"али";s:3:"104";s:6:"аро";s:3:"105";s:6:"бер";s:3:"106";s:6:"бил";s:3:"107";s:6:"бор";s:3:"108";s:6:"ими";s:3:"109";s:6:"ист";s:3:"110";s:5:"он ";s:3:"111";s:6:"рин";s:3:"112";s:6:"тер";s:3:"113";s:6:"тил";s:3:"114";s:5:"ун ";s:3:"115";s:6:"фра";s:3:"116";s:6:"қил";s:3:"117";s:5:" ба";s:3:"118";s:5:" ол";s:3:"119";s:6:"анс";s:3:"120";s:6:"ефт";s:3:"121";s:6:"зир";s:3:"122";s:6:"кат";s:3:"123";s:6:"мил";s:3:"124";s:6:"неф";s:3:"125";s:6:"саг";s:3:"126";s:5:"чи ";s:3:"127";s:6:"ўра";s:3:"128";s:5:" на";s:3:"129";s:5:" те";s:3:"130";s:5:" эн";s:3:"131";s:5:"а э";s:3:"132";s:5:"ам ";s:3:"133";s:6:"арн";s:3:"134";s:5:"ат ";s:3:"135";s:5:"иш ";s:3:"136";s:5:"ма ";s:3:"137";s:6:"нла";s:3:"138";s:6:"рли";s:3:"139";s:6:"чил";s:3:"140";s:6:"шга";s:3:"141";s:5:" иш";s:3:"142";s:5:" му";s:3:"143";s:5:" ўқ";s:3:"144";s:6:"ара";s:3:"145";s:6:"ваз";s:3:"146";s:5:"и у";s:3:"147";s:5:"иқ ";s:3:"148";s:6:"моқ";s:3:"149";s:6:"рим";s:3:"150";s:6:"учу";s:3:"151";s:6:"чун";s:3:"152";s:5:"ши ";s:3:"153";s:6:"энг";s:3:"154";s:6:"қув";s:3:"155";s:6:"ҳам";s:3:"156";s:5:" сў";s:3:"157";s:5:" ши";s:3:"158";s:6:"бар";s:3:"159";s:6:"бек";s:3:"160";s:6:"дам";s:3:"161";s:5:"и ҳ";s:3:"162";s:6:"иши";s:3:"163";s:6:"лад";s:3:"164";s:6:"оли";s:3:"165";s:6:"олл";s:3:"166";s:6:"ори";s:3:"167";s:6:"оқд";s:3:"168";s:5:"р б";s:3:"169";s:5:"ра ";s:3:"170";s:6:"рла";s:3:"171";s:6:"уни";s:3:"172";s:5:"фт ";s:3:"173";s:6:"ўлг";s:3:"174";s:6:"ўқу";s:3:"175";s:5:" де";s:3:"176";s:5:" ка";s:3:"177";s:5:" қў";s:3:"178";s:5:"а ў";s:3:"179";s:6:"аба";s:3:"180";s:6:"амм";s:3:"181";s:6:"атл";s:3:"182";s:5:"б к";s:3:"183";s:6:"бош";s:3:"184";s:6:"збе";s:3:"185";s:5:"и в";s:3:"186";s:5:"им ";s:3:"187";s:5:"ин ";s:3:"188";s:6:"ишл";s:3:"189";s:6:"лаб";s:3:"190";s:6:"лей";s:3:"191";s:6:"мин";s:3:"192";s:5:"н д";s:3:"193";s:6:"нда";s:3:"194";s:5:"оқ ";s:3:"195";s:5:"р м";s:3:"196";s:6:"рил";s:3:"197";s:6:"сид";s:3:"198";s:6:"тал";s:3:"199";s:6:"тан";s:3:"200";s:6:"тид";s:3:"201";s:6:"тон";s:3:"202";s:6:"ўзб";s:3:"203";s:5:" ам";s:3:"204";s:5:" ки";s:3:"205";s:5:"а ҳ";s:3:"206";s:6:"анг";s:3:"207";s:6:"анд";s:3:"208";s:6:"арт";s:3:"209";s:6:"аёт";s:3:"210";s:6:"дир";s:3:"211";s:6:"ент";s:3:"212";s:5:"и д";s:3:"213";s:5:"и м";s:3:"214";s:5:"и о";s:3:"215";s:5:"и э";s:3:"216";s:6:"иро";s:3:"217";s:6:"йти";s:3:"218";s:6:"нсу";s:3:"219";s:6:"оди";s:3:"220";s:5:"ор ";s:3:"221";s:5:"си ";s:3:"222";s:6:"тиш";s:3:"223";s:6:"тоб";s:3:"224";s:6:"эти";s:3:"225";s:6:"қар";s:3:"226";s:6:"қда";s:3:"227";s:5:" бл";s:3:"228";s:5:" ге";s:3:"229";s:5:" до";s:3:"230";s:5:" ду";s:3:"231";s:5:" но";s:3:"232";s:5:" пр";s:3:"233";s:5:" ра";s:3:"234";s:5:" фо";s:3:"235";s:5:" қо";s:3:"236";s:5:"а м";s:3:"237";s:5:"а о";s:3:"238";s:6:"айд";s:3:"239";s:6:"ало";s:3:"240";s:6:"ама";s:3:"241";s:6:"бле";s:3:"242";s:5:"г н";s:3:"243";s:6:"дол";s:3:"244";s:6:"ейр";s:3:"245";s:5:"ек ";s:3:"246";s:6:"ерг";s:3:"247";s:6:"жар";s:3:"248";s:6:"зид";s:3:"249";s:5:"и к";s:3:"250";s:5:"и ф";s:3:"251";s:5:"ий ";s:3:"252";s:6:"ило";s:3:"253";s:6:"лди";s:3:"254";s:6:"либ";s:3:"255";s:6:"лин";s:3:"256";s:5:"ми ";s:3:"257";s:6:"мма";s:3:"258";s:5:"н в";s:3:"259";s:5:"н к";s:3:"260";s:5:"н ў";s:3:"261";s:5:"н ҳ";s:3:"262";s:6:"ози";s:3:"263";s:6:"ора";s:3:"264";s:6:"оси";s:3:"265";s:6:"рас";s:3:"266";s:6:"риш";s:3:"267";s:6:"рка";s:3:"268";s:6:"роқ";s:3:"269";s:6:"сто";s:3:"270";s:6:"тин";s:3:"271";s:6:"хат";s:3:"272";s:6:"шир";s:3:"273";s:5:" ав";s:3:"274";s:5:" рў";s:3:"275";s:5:" ту";s:3:"276";s:5:" ўт";s:3:"277";s:5:"а п";s:3:"278";s:6:"авт";s:3:"279";s:6:"ада";s:3:"280";s:6:"аза";s:3:"281";s:6:"анл";s:3:"282";s:5:"б б";s:3:"283";s:6:"бой";s:3:"284";s:5:"бу ";s:3:"285";s:6:"вто";s:3:"286";s:5:"г э";s:3:"287";s:6:"гин";s:3:"288";s:6:"дар";s:3:"289";s:6:"ден";s:3:"290";s:6:"дун";s:3:"291";s:6:"иде";s:3:"292";s:6:"ион";s:3:"293";s:6:"ирл";s:3:"294";s:6:"ишг";s:3:"295";s:6:"йха";s:3:"296";s:6:"кел";s:3:"297";s:6:"кўп";s:3:"298";s:6:"лио";s:3:"299";}s:10:"vietnamese";a:300:{s:3:"ng ";s:1:"0";s:3:" th";s:1:"1";s:3:" ch";s:1:"2";s:3:"g t";s:1:"3";s:3:" nh";s:1:"4";s:4:"ông";s:1:"5";s:3:" kh";s:1:"6";s:3:" tr";s:1:"7";s:3:"nh ";s:1:"8";s:4:" cô";s:1:"9";s:4:"côn";s:2:"10";s:3:" ty";s:2:"11";s:3:"ty ";s:2:"12";s:3:"i t";s:2:"13";s:3:"n t";s:2:"14";s:3:" ng";s:2:"15";s:5:"ại ";s:2:"16";s:3:" ti";s:2:"17";s:3:"ch ";s:2:"18";s:3:"y l";s:2:"19";s:5:"ền ";s:2:"20";s:5:" đư";s:2:"21";s:3:"hi ";s:2:"22";s:5:" gở";s:2:"23";s:5:"gởi";s:2:"24";s:5:"iền";s:2:"25";s:5:"tiề";s:2:"26";s:5:"ởi ";s:2:"27";s:3:" gi";s:2:"28";s:3:" le";s:2:"29";s:3:" vi";s:2:"30";s:3:"cho";s:2:"31";s:3:"ho ";s:2:"32";s:4:"khá";s:2:"33";s:4:" và";s:2:"34";s:4:"hác";s:2:"35";s:3:" ph";s:2:"36";s:3:"am ";s:2:"37";s:4:"hàn";s:2:"38";s:4:"ách";s:2:"39";s:4:"ôi ";s:2:"40";s:3:"i n";s:2:"41";s:6:"ược";s:2:"42";s:5:"ợc ";s:2:"43";s:4:" tô";s:2:"44";s:4:"chú";s:2:"45";s:5:"iệt";s:2:"46";s:4:"tôi";s:2:"47";s:4:"ên ";s:2:"48";s:4:"úng";s:2:"49";s:5:"ệt ";s:2:"50";s:4:" có";s:2:"51";s:3:"c t";s:2:"52";s:4:"có ";s:2:"53";s:4:"hún";s:2:"54";s:5:"việ";s:2:"55";s:7:"đượ";s:2:"56";s:3:" na";s:2:"57";s:3:"g c";s:2:"58";s:3:"i c";s:2:"59";s:3:"n c";s:2:"60";s:3:"n n";s:2:"61";s:3:"t n";s:2:"62";s:4:"và ";s:2:"63";s:3:"n l";s:2:"64";s:4:"n đ";s:2:"65";s:4:"àng";s:2:"66";s:4:"ác ";s:2:"67";s:5:"ất ";s:2:"68";s:3:"h l";s:2:"69";s:3:"nam";s:2:"70";s:4:"ân ";s:2:"71";s:4:"ăm ";s:2:"72";s:4:" hà";s:2:"73";s:4:" là";s:2:"74";s:4:" nă";s:2:"75";s:3:" qu";s:2:"76";s:5:" tạ";s:2:"77";s:3:"g m";s:2:"78";s:4:"năm";s:2:"79";s:5:"tại";s:2:"80";s:5:"ới ";s:2:"81";s:5:" lẹ";s:2:"82";s:3:"ay ";s:2:"83";s:3:"e g";s:2:"84";s:3:"h h";s:2:"85";s:3:"i v";s:2:"86";s:4:"i đ";s:2:"87";s:3:"le ";s:2:"88";s:5:"lẹ ";s:2:"89";s:5:"ều ";s:2:"90";s:5:"ời ";s:2:"91";s:4:"hân";s:2:"92";s:3:"nhi";s:2:"93";s:3:"t t";s:2:"94";s:5:" củ";s:2:"95";s:5:" mộ";s:2:"96";s:5:" về";s:2:"97";s:4:" đi";s:2:"98";s:3:"an ";s:2:"99";s:5:"của";s:3:"100";s:4:"là ";s:3:"101";s:5:"một";s:3:"102";s:5:"về ";s:3:"103";s:4:"ành";s:3:"104";s:5:"ết ";s:3:"105";s:5:"ột ";s:3:"106";s:5:"ủa ";s:3:"107";s:3:" bi";s:3:"108";s:4:" cá";s:3:"109";s:3:"a c";s:3:"110";s:3:"anh";s:3:"111";s:4:"các";s:3:"112";s:3:"h c";s:3:"113";s:5:"iều";s:3:"114";s:3:"m t";s:3:"115";s:5:"ện ";s:3:"116";s:3:" ho";s:3:"117";s:3:"'s ";s:3:"118";s:3:"ave";s:3:"119";s:3:"e's";s:3:"120";s:3:"el ";s:3:"121";s:3:"g n";s:3:"122";s:3:"le'";s:3:"123";s:3:"n v";s:3:"124";s:3:"o c";s:3:"125";s:3:"rav";s:3:"126";s:3:"s t";s:3:"127";s:3:"thi";s:3:"128";s:3:"tra";s:3:"129";s:3:"vel";s:3:"130";s:5:"ận ";s:3:"131";s:5:"ến ";s:3:"132";s:3:" ba";s:3:"133";s:3:" cu";s:3:"134";s:3:" sa";s:3:"135";s:5:" đó";s:3:"136";s:6:" đế";s:3:"137";s:3:"c c";s:3:"138";s:3:"chu";s:3:"139";s:5:"hiề";s:3:"140";s:3:"huy";s:3:"141";s:3:"khi";s:3:"142";s:4:"nhâ";s:3:"143";s:4:"như";s:3:"144";s:3:"ong";s:3:"145";s:3:"ron";s:3:"146";s:3:"thu";s:3:"147";s:4:"thư";s:3:"148";s:3:"tro";s:3:"149";s:3:"y c";s:3:"150";s:4:"ày ";s:3:"151";s:6:"đến";s:3:"152";s:6:"ười";s:3:"153";s:6:"ườn";s:3:"154";s:5:"ề v";s:3:"155";s:5:"ờng";s:3:"156";s:5:" vớ";s:3:"157";s:5:"cuộ";s:3:"158";s:4:"g đ";s:3:"159";s:5:"iết";s:3:"160";s:5:"iện";s:3:"161";s:4:"ngà";s:3:"162";s:3:"o t";s:3:"163";s:3:"u c";s:3:"164";s:5:"uộc";s:3:"165";s:5:"với";s:3:"166";s:4:"à c";s:3:"167";s:4:"ài ";s:3:"168";s:4:"ơng";s:3:"169";s:5:"ươn";s:3:"170";s:5:"ải ";s:3:"171";s:5:"ộc ";s:3:"172";s:5:"ức ";s:3:"173";s:3:" an";s:3:"174";s:5:" lậ";s:3:"175";s:3:" ra";s:3:"176";s:5:" sẽ";s:3:"177";s:5:" số";s:3:"178";s:5:" tổ";s:3:"179";s:3:"a k";s:3:"180";s:5:"biế";s:3:"181";s:3:"c n";s:3:"182";s:4:"c đ";s:3:"183";s:5:"chứ";s:3:"184";s:3:"g v";s:3:"185";s:3:"gia";s:3:"186";s:4:"gày";s:3:"187";s:4:"hán";s:3:"188";s:4:"hôn";s:3:"189";s:4:"hư ";s:3:"190";s:5:"hức";s:3:"191";s:3:"i g";s:3:"192";s:3:"i h";s:3:"193";s:3:"i k";s:3:"194";s:3:"i p";s:3:"195";s:4:"iên";s:3:"196";s:4:"khô";s:3:"197";s:5:"lập";s:3:"198";s:3:"n k";s:3:"199";s:3:"ra ";s:3:"200";s:4:"rên";s:3:"201";s:5:"sẽ ";s:3:"202";s:3:"t c";s:3:"203";s:4:"thà";s:3:"204";s:4:"trê";s:3:"205";s:5:"tổ ";s:3:"206";s:3:"u n";s:3:"207";s:3:"y t";s:3:"208";s:4:"ình";s:3:"209";s:5:"ấy ";s:3:"210";s:5:"ập ";s:3:"211";s:5:"ổ c";s:3:"212";s:4:" má";s:3:"213";s:6:" để";s:3:"214";s:3:"ai ";s:3:"215";s:3:"c s";s:3:"216";s:6:"gườ";s:3:"217";s:3:"h v";s:3:"218";s:3:"hoa";s:3:"219";s:5:"hoạ";s:3:"220";s:3:"inh";s:3:"221";s:3:"m n";s:3:"222";s:4:"máy";s:3:"223";s:3:"n g";s:3:"224";s:4:"ngư";s:3:"225";s:5:"nhậ";s:3:"226";s:3:"o n";s:3:"227";s:3:"oa ";s:3:"228";s:4:"oàn";s:3:"229";s:3:"p c";s:3:"230";s:5:"số ";s:3:"231";s:4:"t đ";s:3:"232";s:3:"y v";s:3:"233";s:4:"ào ";s:3:"234";s:4:"áy ";s:3:"235";s:4:"ăn ";s:3:"236";s:5:"đó ";s:3:"237";s:6:"để ";s:3:"238";s:6:"ước";s:3:"239";s:5:"ần ";s:3:"240";s:5:"ển ";s:3:"241";s:5:"ớc ";s:3:"242";s:4:" bá";s:3:"243";s:4:" cơ";s:3:"244";s:5:" cả";s:3:"245";s:5:" cầ";s:3:"246";s:5:" họ";s:3:"247";s:5:" kỳ";s:3:"248";s:3:" li";s:3:"249";s:5:" mạ";s:3:"250";s:5:" sở";s:3:"251";s:5:" tặ";s:3:"252";s:4:" vé";s:3:"253";s:5:" vụ";s:3:"254";s:6:" đạ";s:3:"255";s:4:"a đ";s:3:"256";s:3:"bay";s:3:"257";s:4:"cơ ";s:3:"258";s:3:"g s";s:3:"259";s:3:"han";s:3:"260";s:5:"hươ";s:3:"261";s:3:"i s";s:3:"262";s:5:"kỳ ";s:3:"263";s:3:"m c";s:3:"264";s:3:"n m";s:3:"265";s:3:"n p";s:3:"266";s:3:"o b";s:3:"267";s:5:"oại";s:3:"268";s:3:"qua";s:3:"269";s:5:"sở ";s:3:"270";s:3:"tha";s:3:"271";s:4:"thá";s:3:"272";s:5:"tặn";s:3:"273";s:4:"vào";s:3:"274";s:4:"vé ";s:3:"275";s:5:"vụ ";s:3:"276";s:3:"y b";s:3:"277";s:4:"àn ";s:3:"278";s:4:"áng";s:3:"279";s:4:"ơ s";s:3:"280";s:5:"ầu ";s:3:"281";s:5:"ật ";s:3:"282";s:5:"ặng";s:3:"283";s:5:"ọc ";s:3:"284";s:5:"ở t";s:3:"285";s:5:"ững";s:3:"286";s:3:" du";s:3:"287";s:3:" lu";s:3:"288";s:3:" ta";s:3:"289";s:3:" to";s:3:"290";s:5:" từ";s:3:"291";s:5:" ở ";s:3:"292";s:3:"a v";s:3:"293";s:3:"ao ";s:3:"294";s:3:"c v";s:3:"295";s:5:"cả ";s:3:"296";s:3:"du ";s:3:"297";s:3:"g l";s:3:"298";s:5:"giả";s:3:"299";}s:5:"welsh";a:300:{s:3:"yn ";s:1:"0";s:3:"dd ";s:1:"1";s:3:" yn";s:1:"2";s:3:" y ";s:1:"3";s:3:"ydd";s:1:"4";s:3:"eth";s:1:"5";s:3:"th ";s:1:"6";s:3:" i ";s:1:"7";s:3:"aet";s:1:"8";s:3:"d y";s:1:"9";s:3:"ch ";s:2:"10";s:3:"od ";s:2:"11";s:3:"ol ";s:2:"12";s:3:"edd";s:2:"13";s:3:" ga";s:2:"14";s:3:" gw";s:2:"15";s:3:"'r ";s:2:"16";s:3:"au ";s:2:"17";s:3:"ddi";s:2:"18";s:3:"ad ";s:2:"19";s:3:" cy";s:2:"20";s:3:" gy";s:2:"21";s:3:" ei";s:2:"22";s:3:" o ";s:2:"23";s:3:"iad";s:2:"24";s:3:"yr ";s:2:"25";s:3:"an ";s:2:"26";s:3:"bod";s:2:"27";s:3:"wed";s:2:"28";s:3:" bo";s:2:"29";s:3:" dd";s:2:"30";s:3:"el ";s:2:"31";s:3:"n y";s:2:"32";s:3:" am";s:2:"33";s:3:"di ";s:2:"34";s:3:"edi";s:2:"35";s:3:"on ";s:2:"36";s:3:" we";s:2:"37";s:3:" ym";s:2:"38";s:3:" ar";s:2:"39";s:3:" rh";s:2:"40";s:3:"odd";s:2:"41";s:3:" ca";s:2:"42";s:3:" ma";s:2:"43";s:3:"ael";s:2:"44";s:3:"oed";s:2:"45";s:3:"dae";s:2:"46";s:3:"n a";s:2:"47";s:3:"dda";s:2:"48";s:3:"er ";s:2:"49";s:3:"h y";s:2:"50";s:3:"all";s:2:"51";s:3:"ei ";s:2:"52";s:3:" ll";s:2:"53";s:3:"am ";s:2:"54";s:3:"eu ";s:2:"55";s:3:"fod";s:2:"56";s:3:"fyd";s:2:"57";s:3:"l y";s:2:"58";s:3:"n g";s:2:"59";s:3:"wyn";s:2:"60";s:3:"d a";s:2:"61";s:3:"i g";s:2:"62";s:3:"mae";s:2:"63";s:3:"neu";s:2:"64";s:3:"os ";s:2:"65";s:3:" ne";s:2:"66";s:3:"d i";s:2:"67";s:3:"dod";s:2:"68";s:3:"dol";s:2:"69";s:3:"n c";s:2:"70";s:3:"r h";s:2:"71";s:3:"wyd";s:2:"72";s:3:"wyr";s:2:"73";s:3:"ai ";s:2:"74";s:3:"ar ";s:2:"75";s:3:"in ";s:2:"76";s:3:"rth";s:2:"77";s:3:" fy";s:2:"78";s:3:" he";s:2:"79";s:3:" me";s:2:"80";s:3:" yr";s:2:"81";s:3:"'n ";s:2:"82";s:3:"dia";s:2:"83";s:3:"est";s:2:"84";s:3:"h c";s:2:"85";s:3:"hai";s:2:"86";s:3:"i d";s:2:"87";s:3:"id ";s:2:"88";s:3:"r y";s:2:"89";s:3:"y b";s:2:"90";s:3:" dy";s:2:"91";s:3:" ha";s:2:"92";s:3:"ada";s:2:"93";s:3:"i b";s:2:"94";s:3:"n i";s:2:"95";s:3:"ote";s:2:"96";s:3:"rot";s:2:"97";s:3:"tes";s:2:"98";s:3:"y g";s:2:"99";s:3:"yd ";s:3:"100";s:3:" ad";s:3:"101";s:3:" mr";s:3:"102";s:3:" un";s:3:"103";s:3:"cyn";s:3:"104";s:3:"dau";s:3:"105";s:3:"ddy";s:3:"106";s:3:"edo";s:3:"107";s:3:"i c";s:3:"108";s:3:"i w";s:3:"109";s:3:"ith";s:3:"110";s:3:"lae";s:3:"111";s:3:"lla";s:3:"112";s:3:"nd ";s:3:"113";s:3:"oda";s:3:"114";s:3:"ryd";s:3:"115";s:3:"tho";s:3:"116";s:3:" a ";s:3:"117";s:3:" dr";s:3:"118";s:3:"aid";s:3:"119";s:3:"ain";s:3:"120";s:3:"ddo";s:3:"121";s:3:"dyd";s:3:"122";s:3:"fyn";s:3:"123";s:3:"gyn";s:3:"124";s:3:"hol";s:3:"125";s:3:"io ";s:3:"126";s:3:"o a";s:3:"127";s:3:"wch";s:3:"128";s:3:"wyb";s:3:"129";s:3:"ybo";s:3:"130";s:3:"ych";s:3:"131";s:3:" br";s:3:"132";s:3:" by";s:3:"133";s:3:" di";s:3:"134";s:3:" fe";s:3:"135";s:3:" na";s:3:"136";s:3:" o'";s:3:"137";s:3:" pe";s:3:"138";s:3:"art";s:3:"139";s:3:"byd";s:3:"140";s:3:"dro";s:3:"141";s:3:"gal";s:3:"142";s:3:"l e";s:3:"143";s:3:"lai";s:3:"144";s:3:"mr ";s:3:"145";s:3:"n n";s:3:"146";s:3:"r a";s:3:"147";s:3:"rhy";s:3:"148";s:3:"wn ";s:3:"149";s:3:"ynn";s:3:"150";s:3:" on";s:3:"151";s:3:" r ";s:3:"152";s:3:"cae";s:3:"153";s:3:"d g";s:3:"154";s:3:"d o";s:3:"155";s:3:"d w";s:3:"156";s:3:"gan";s:3:"157";s:3:"gwy";s:3:"158";s:3:"n d";s:3:"159";s:3:"n f";s:3:"160";s:3:"n o";s:3:"161";s:3:"ned";s:3:"162";s:3:"ni ";s:3:"163";s:3:"o'r";s:3:"164";s:3:"r d";s:3:"165";s:3:"ud ";s:3:"166";s:3:"wei";s:3:"167";s:3:"wrt";s:3:"168";s:3:" an";s:3:"169";s:3:" cw";s:3:"170";s:3:" da";s:3:"171";s:3:" ni";s:3:"172";s:3:" pa";s:3:"173";s:3:" pr";s:3:"174";s:3:" wy";s:3:"175";s:3:"d e";s:3:"176";s:3:"dai";s:3:"177";s:3:"dim";s:3:"178";s:3:"eud";s:3:"179";s:3:"gwa";s:3:"180";s:3:"idd";s:3:"181";s:3:"im ";s:3:"182";s:3:"iri";s:3:"183";s:3:"lwy";s:3:"184";s:3:"n b";s:3:"185";s:3:"nol";s:3:"186";s:3:"r o";s:3:"187";s:3:"rwy";s:3:"188";s:3:" ch";s:3:"189";s:3:" er";s:3:"190";s:3:" fo";s:3:"191";s:3:" ge";s:3:"192";s:3:" hy";s:3:"193";s:3:" i'";s:3:"194";s:3:" ro";s:3:"195";s:3:" sa";s:3:"196";s:3:" tr";s:3:"197";s:3:"bob";s:3:"198";s:3:"cwy";s:3:"199";s:3:"cyf";s:3:"200";s:3:"dio";s:3:"201";s:3:"dyn";s:3:"202";s:3:"eit";s:3:"203";s:3:"hel";s:3:"204";s:3:"hyn";s:3:"205";s:3:"ich";s:3:"206";s:3:"ll ";s:3:"207";s:3:"mdd";s:3:"208";s:3:"n r";s:3:"209";s:3:"ond";s:3:"210";s:3:"pro";s:3:"211";s:3:"r c";s:3:"212";s:3:"r g";s:3:"213";s:3:"red";s:3:"214";s:3:"rha";s:3:"215";s:3:"u a";s:3:"216";s:3:"u c";s:3:"217";s:3:"u y";s:3:"218";s:3:"y c";s:3:"219";s:3:"ymd";s:3:"220";s:3:"ymr";s:3:"221";s:3:"yw ";s:3:"222";s:3:" ac";s:3:"223";s:3:" be";s:3:"224";s:3:" bl";s:3:"225";s:3:" co";s:3:"226";s:3:" os";s:3:"227";s:3:"adw";s:3:"228";s:3:"ae ";s:3:"229";s:3:"af ";s:3:"230";s:3:"d p";s:3:"231";s:3:"efn";s:3:"232";s:3:"eic";s:3:"233";s:3:"en ";s:3:"234";s:3:"eol";s:3:"235";s:3:"es ";s:3:"236";s:3:"fer";s:3:"237";s:3:"gel";s:3:"238";s:3:"h g";s:3:"239";s:3:"hod";s:3:"240";s:3:"ied";s:3:"241";s:3:"ir ";s:3:"242";s:3:"laf";s:3:"243";s:3:"n h";s:3:"244";s:3:"na ";s:3:"245";s:3:"nyd";s:3:"246";s:3:"odo";s:3:"247";s:3:"ofy";s:3:"248";s:3:"rdd";s:3:"249";s:3:"rie";s:3:"250";s:3:"ros";s:3:"251";s:3:"stw";s:3:"252";s:3:"twy";s:3:"253";s:3:"yda";s:3:"254";s:3:"yng";s:3:"255";s:3:" at";s:3:"256";s:3:" de";s:3:"257";s:3:" go";s:3:"258";s:3:" id";s:3:"259";s:3:" oe";s:3:"260";s:4:" â ";s:3:"261";s:3:"'ch";s:3:"262";s:3:"ac ";s:3:"263";s:3:"ach";s:3:"264";s:3:"ae'";s:3:"265";s:3:"al ";s:3:"266";s:3:"bl ";s:3:"267";s:3:"d c";s:3:"268";s:3:"d l";s:3:"269";s:3:"dan";s:3:"270";s:3:"dde";s:3:"271";s:3:"ddw";s:3:"272";s:3:"dir";s:3:"273";s:3:"dla";s:3:"274";s:3:"ed ";s:3:"275";s:3:"ela";s:3:"276";s:3:"ell";s:3:"277";s:3:"ene";s:3:"278";s:3:"ewn";s:3:"279";s:3:"gyd";s:3:"280";s:3:"hau";s:3:"281";s:3:"hyw";s:3:"282";s:3:"i a";s:3:"283";s:3:"i f";s:3:"284";s:3:"iol";s:3:"285";s:3:"ion";s:3:"286";s:3:"l a";s:3:"287";s:3:"l i";s:3:"288";s:3:"lia";s:3:"289";s:3:"med";s:3:"290";s:3:"mon";s:3:"291";s:3:"n s";s:3:"292";s:3:"no ";s:3:"293";s:3:"obl";s:3:"294";s:3:"ola";s:3:"295";s:3:"ref";s:3:"296";s:3:"rn ";s:3:"297";s:3:"thi";s:3:"298";s:3:"un ";s:3:"299";}}s:18:"trigram-unicodemap";a:13:{s:11:"Basic Latin";a:38:{s:8:"albanian";i:661;s:5:"azeri";i:653;s:7:"bengali";i:1;s:7:"cebuano";i:750;s:8:"croatian";i:733;s:5:"czech";i:652;s:6:"danish";i:734;s:5:"dutch";i:741;s:7:"english";i:723;s:8:"estonian";i:739;s:7:"finnish";i:743;s:6:"french";i:733;s:6:"german";i:750;s:5:"hausa";i:752;s:8:"hawaiian";i:751;s:9:"hungarian";i:693;s:9:"icelandic";i:662;s:10:"indonesian";i:776;s:7:"italian";i:741;s:5:"latin";i:764;s:7:"latvian";i:693;s:10:"lithuanian";i:738;s:9:"mongolian";i:19;s:9:"norwegian";i:742;s:6:"pidgin";i:702;s:6:"polish";i:701;s:10:"portuguese";i:726;s:8:"romanian";i:714;s:6:"slovak";i:677;s:7:"slovene";i:740;s:6:"somali";i:755;s:7:"spanish";i:749;s:7:"swahili";i:770;s:7:"swedish";i:717;s:7:"tagalog";i:767;s:7:"turkish";i:673;s:10:"vietnamese";i:503;s:5:"welsh";i:728;}s:18:"Latin-1 Supplement";a:21:{s:8:"albanian";i:68;s:5:"azeri";i:10;s:5:"czech";i:51;s:6:"danish";i:13;s:8:"estonian";i:19;s:7:"finnish";i:39;s:6:"french";i:21;s:6:"german";i:8;s:9:"hungarian";i:72;s:9:"icelandic";i:80;s:7:"italian";i:3;s:9:"norwegian";i:5;s:6:"polish";i:6;s:10:"portuguese";i:18;s:8:"romanian";i:9;s:6:"slovak";i:37;s:7:"spanish";i:6;s:7:"swedish";i:26;s:7:"turkish";i:25;s:10:"vietnamese";i:56;s:5:"welsh";i:1;}s:14:"[Malformatted]";a:42:{s:8:"albanian";i:68;s:6:"arabic";i:724;s:5:"azeri";i:109;s:7:"bengali";i:1472;s:9:"bulgarian";i:750;s:8:"croatian";i:10;s:5:"czech";i:78;s:6:"danish";i:13;s:8:"estonian";i:19;s:5:"farsi";i:706;s:7:"finnish";i:39;s:6:"french";i:21;s:6:"german";i:8;s:5:"hausa";i:8;s:5:"hindi";i:1386;s:9:"hungarian";i:74;s:9:"icelandic";i:80;s:7:"italian";i:3;s:6:"kazakh";i:767;s:6:"kyrgyz";i:767;s:7:"latvian";i:56;s:10:"lithuanian";i:30;s:10:"macedonian";i:755;s:9:"mongolian";i:743;s:6:"nepali";i:1514;s:9:"norwegian";i:5;s:6:"pashto";i:677;s:6:"polish";i:45;s:10:"portuguese";i:18;s:8:"romanian";i:31;s:7:"russian";i:759;s:7:"serbian";i:757;s:6:"slovak";i:45;s:7:"slovene";i:10;s:7:"spanish";i:6;s:7:"swedish";i:26;s:7:"turkish";i:87;s:9:"ukrainian";i:748;s:4:"urdu";i:682;s:5:"uzbek";i:773;s:10:"vietnamese";i:289;s:5:"welsh";i:1;}s:6:"Arabic";a:4:{s:6:"arabic";i:724;s:5:"farsi";i:706;s:6:"pashto";i:677;s:4:"urdu";i:682;}s:16:"Latin Extended-B";a:3:{s:5:"azeri";i:73;s:5:"hausa";i:8;s:10:"vietnamese";i:19;}s:16:"Latin Extended-A";a:12:{s:5:"azeri";i:25;s:8:"croatian";i:10;s:5:"czech";i:27;s:9:"hungarian";i:2;s:7:"latvian";i:56;s:10:"lithuanian";i:30;s:6:"polish";i:39;s:8:"romanian";i:22;s:6:"slovak";i:8;s:7:"slovene";i:10;s:7:"turkish";i:62;s:10:"vietnamese";i:20;}s:27:"Combining Diacritical Marks";a:1:{s:5:"azeri";i:1;}s:7:"Bengali";a:1:{s:7:"bengali";i:714;}s:8:"Gujarati";a:1:{s:7:"bengali";i:16;}s:8:"Gurmukhi";a:1:{s:7:"bengali";i:6;}s:8:"Cyrillic";a:9:{s:9:"bulgarian";i:750;s:6:"kazakh";i:767;s:6:"kyrgyz";i:767;s:10:"macedonian";i:755;s:9:"mongolian";i:743;s:7:"russian";i:759;s:7:"serbian";i:757;s:9:"ukrainian";i:748;s:5:"uzbek";i:773;}s:10:"Devanagari";a:2:{s:5:"hindi";i:693;s:6:"nepali";i:757;}s:25:"Latin Extended Additional";a:1:{s:10:"vietnamese";i:97;}}}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/language-detect/unicode_blocks.dat b/inc/3rdparty/libraries/language-detect/unicode_blocks.dat
new file mode 100644
index 00000000..3b24cd2c
--- /dev/null
+++ b/inc/3rdparty/libraries/language-detect/unicode_blocks.dat
@@ -0,0 +1 @@
+a:145:{i:0;a:3:{i:0;s:6:"0x0000";i:1;s:6:"0x007F";i:2;s:11:"Basic Latin";}i:1;a:3:{i:0;s:6:"0x0080";i:1;s:6:"0x00FF";i:2;s:18:"Latin-1 Supplement";}i:2;a:3:{i:0;s:6:"0x0100";i:1;s:6:"0x017F";i:2;s:16:"Latin Extended-A";}i:3;a:3:{i:0;s:6:"0x0180";i:1;s:6:"0x024F";i:2;s:16:"Latin Extended-B";}i:4;a:3:{i:0;s:6:"0x0250";i:1;s:6:"0x02AF";i:2;s:14:"IPA Extensions";}i:5;a:3:{i:0;s:6:"0x02B0";i:1;s:6:"0x02FF";i:2;s:24:"Spacing Modifier Letters";}i:6;a:3:{i:0;s:6:"0x0300";i:1;s:6:"0x036F";i:2;s:27:"Combining Diacritical Marks";}i:7;a:3:{i:0;s:6:"0x0370";i:1;s:6:"0x03FF";i:2;s:16:"Greek and Coptic";}i:8;a:3:{i:0;s:6:"0x0400";i:1;s:6:"0x04FF";i:2;s:8:"Cyrillic";}i:9;a:3:{i:0;s:6:"0x0500";i:1;s:6:"0x052F";i:2;s:19:"Cyrillic Supplement";}i:10;a:3:{i:0;s:6:"0x0530";i:1;s:6:"0x058F";i:2;s:8:"Armenian";}i:11;a:3:{i:0;s:6:"0x0590";i:1;s:6:"0x05FF";i:2;s:6:"Hebrew";}i:12;a:3:{i:0;s:6:"0x0600";i:1;s:6:"0x06FF";i:2;s:6:"Arabic";}i:13;a:3:{i:0;s:6:"0x0700";i:1;s:6:"0x074F";i:2;s:6:"Syriac";}i:14;a:3:{i:0;s:6:"0x0750";i:1;s:6:"0x077F";i:2;s:17:"Arabic Supplement";}i:15;a:3:{i:0;s:6:"0x0780";i:1;s:6:"0x07BF";i:2;s:6:"Thaana";}i:16;a:3:{i:0;s:6:"0x0900";i:1;s:6:"0x097F";i:2;s:10:"Devanagari";}i:17;a:3:{i:0;s:6:"0x0980";i:1;s:6:"0x09FF";i:2;s:7:"Bengali";}i:18;a:3:{i:0;s:6:"0x0A00";i:1;s:6:"0x0A7F";i:2;s:8:"Gurmukhi";}i:19;a:3:{i:0;s:6:"0x0A80";i:1;s:6:"0x0AFF";i:2;s:8:"Gujarati";}i:20;a:3:{i:0;s:6:"0x0B00";i:1;s:6:"0x0B7F";i:2;s:5:"Oriya";}i:21;a:3:{i:0;s:6:"0x0B80";i:1;s:6:"0x0BFF";i:2;s:5:"Tamil";}i:22;a:3:{i:0;s:6:"0x0C00";i:1;s:6:"0x0C7F";i:2;s:6:"Telugu";}i:23;a:3:{i:0;s:6:"0x0C80";i:1;s:6:"0x0CFF";i:2;s:7:"Kannada";}i:24;a:3:{i:0;s:6:"0x0D00";i:1;s:6:"0x0D7F";i:2;s:9:"Malayalam";}i:25;a:3:{i:0;s:6:"0x0D80";i:1;s:6:"0x0DFF";i:2;s:7:"Sinhala";}i:26;a:3:{i:0;s:6:"0x0E00";i:1;s:6:"0x0E7F";i:2;s:4:"Thai";}i:27;a:3:{i:0;s:6:"0x0E80";i:1;s:6:"0x0EFF";i:2;s:3:"Lao";}i:28;a:3:{i:0;s:6:"0x0F00";i:1;s:6:"0x0FFF";i:2;s:7:"Tibetan";}i:29;a:3:{i:0;s:6:"0x1000";i:1;s:6:"0x109F";i:2;s:7:"Myanmar";}i:30;a:3:{i:0;s:6:"0x10A0";i:1;s:6:"0x10FF";i:2;s:8:"Georgian";}i:31;a:3:{i:0;s:6:"0x1100";i:1;s:6:"0x11FF";i:2;s:11:"Hangul Jamo";}i:32;a:3:{i:0;s:6:"0x1200";i:1;s:6:"0x137F";i:2;s:8:"Ethiopic";}i:33;a:3:{i:0;s:6:"0x1380";i:1;s:6:"0x139F";i:2;s:19:"Ethiopic Supplement";}i:34;a:3:{i:0;s:6:"0x13A0";i:1;s:6:"0x13FF";i:2;s:8:"Cherokee";}i:35;a:3:{i:0;s:6:"0x1400";i:1;s:6:"0x167F";i:2;s:37:"Unified Canadian Aboriginal Syllabics";}i:36;a:3:{i:0;s:6:"0x1680";i:1;s:6:"0x169F";i:2;s:5:"Ogham";}i:37;a:3:{i:0;s:6:"0x16A0";i:1;s:6:"0x16FF";i:2;s:5:"Runic";}i:38;a:3:{i:0;s:6:"0x1700";i:1;s:6:"0x171F";i:2;s:7:"Tagalog";}i:39;a:3:{i:0;s:6:"0x1720";i:1;s:6:"0x173F";i:2;s:7:"Hanunoo";}i:40;a:3:{i:0;s:6:"0x1740";i:1;s:6:"0x175F";i:2;s:5:"Buhid";}i:41;a:3:{i:0;s:6:"0x1760";i:1;s:6:"0x177F";i:2;s:8:"Tagbanwa";}i:42;a:3:{i:0;s:6:"0x1780";i:1;s:6:"0x17FF";i:2;s:5:"Khmer";}i:43;a:3:{i:0;s:6:"0x1800";i:1;s:6:"0x18AF";i:2;s:9:"Mongolian";}i:44;a:3:{i:0;s:6:"0x1900";i:1;s:6:"0x194F";i:2;s:5:"Limbu";}i:45;a:3:{i:0;s:6:"0x1950";i:1;s:6:"0x197F";i:2;s:6:"Tai Le";}i:46;a:3:{i:0;s:6:"0x1980";i:1;s:6:"0x19DF";i:2;s:11:"New Tai Lue";}i:47;a:3:{i:0;s:6:"0x19E0";i:1;s:6:"0x19FF";i:2;s:13:"Khmer Symbols";}i:48;a:3:{i:0;s:6:"0x1A00";i:1;s:6:"0x1A1F";i:2;s:8:"Buginese";}i:49;a:3:{i:0;s:6:"0x1D00";i:1;s:6:"0x1D7F";i:2;s:19:"Phonetic Extensions";}i:50;a:3:{i:0;s:6:"0x1D80";i:1;s:6:"0x1DBF";i:2;s:30:"Phonetic Extensions Supplement";}i:51;a:3:{i:0;s:6:"0x1DC0";i:1;s:6:"0x1DFF";i:2;s:38:"Combining Diacritical Marks Supplement";}i:52;a:3:{i:0;s:6:"0x1E00";i:1;s:6:"0x1EFF";i:2;s:25:"Latin Extended Additional";}i:53;a:3:{i:0;s:6:"0x1F00";i:1;s:6:"0x1FFF";i:2;s:14:"Greek Extended";}i:54;a:3:{i:0;s:6:"0x2000";i:1;s:6:"0x206F";i:2;s:19:"General Punctuation";}i:55;a:3:{i:0;s:6:"0x2070";i:1;s:6:"0x209F";i:2;s:27:"Superscripts and Subscripts";}i:56;a:3:{i:0;s:6:"0x20A0";i:1;s:6:"0x20CF";i:2;s:16:"Currency Symbols";}i:57;a:3:{i:0;s:6:"0x20D0";i:1;s:6:"0x20FF";i:2;s:39:"Combining Diacritical Marks for Symbols";}i:58;a:3:{i:0;s:6:"0x2100";i:1;s:6:"0x214F";i:2;s:18:"Letterlike Symbols";}i:59;a:3:{i:0;s:6:"0x2150";i:1;s:6:"0x218F";i:2;s:12:"Number Forms";}i:60;a:3:{i:0;s:6:"0x2190";i:1;s:6:"0x21FF";i:2;s:6:"Arrows";}i:61;a:3:{i:0;s:6:"0x2200";i:1;s:6:"0x22FF";i:2;s:22:"Mathematical Operators";}i:62;a:3:{i:0;s:6:"0x2300";i:1;s:6:"0x23FF";i:2;s:23:"Miscellaneous Technical";}i:63;a:3:{i:0;s:6:"0x2400";i:1;s:6:"0x243F";i:2;s:16:"Control Pictures";}i:64;a:3:{i:0;s:6:"0x2440";i:1;s:6:"0x245F";i:2;s:29:"Optical Character Recognition";}i:65;a:3:{i:0;s:6:"0x2460";i:1;s:6:"0x24FF";i:2;s:22:"Enclosed Alphanumerics";}i:66;a:3:{i:0;s:6:"0x2500";i:1;s:6:"0x257F";i:2;s:11:"Box Drawing";}i:67;a:3:{i:0;s:6:"0x2580";i:1;s:6:"0x259F";i:2;s:14:"Block Elements";}i:68;a:3:{i:0;s:6:"0x25A0";i:1;s:6:"0x25FF";i:2;s:16:"Geometric Shapes";}i:69;a:3:{i:0;s:6:"0x2600";i:1;s:6:"0x26FF";i:2;s:21:"Miscellaneous Symbols";}i:70;a:3:{i:0;s:6:"0x2700";i:1;s:6:"0x27BF";i:2;s:8:"Dingbats";}i:71;a:3:{i:0;s:6:"0x27C0";i:1;s:6:"0x27EF";i:2;s:36:"Miscellaneous Mathematical Symbols-A";}i:72;a:3:{i:0;s:6:"0x27F0";i:1;s:6:"0x27FF";i:2;s:21:"Supplemental Arrows-A";}i:73;a:3:{i:0;s:6:"0x2800";i:1;s:6:"0x28FF";i:2;s:16:"Braille Patterns";}i:74;a:3:{i:0;s:6:"0x2900";i:1;s:6:"0x297F";i:2;s:21:"Supplemental Arrows-B";}i:75;a:3:{i:0;s:6:"0x2980";i:1;s:6:"0x29FF";i:2;s:36:"Miscellaneous Mathematical Symbols-B";}i:76;a:3:{i:0;s:6:"0x2A00";i:1;s:6:"0x2AFF";i:2;s:35:"Supplemental Mathematical Operators";}i:77;a:3:{i:0;s:6:"0x2B00";i:1;s:6:"0x2BFF";i:2;s:32:"Miscellaneous Symbols and Arrows";}i:78;a:3:{i:0;s:6:"0x2C00";i:1;s:6:"0x2C5F";i:2;s:10:"Glagolitic";}i:79;a:3:{i:0;s:6:"0x2C80";i:1;s:6:"0x2CFF";i:2;s:6:"Coptic";}i:80;a:3:{i:0;s:6:"0x2D00";i:1;s:6:"0x2D2F";i:2;s:19:"Georgian Supplement";}i:81;a:3:{i:0;s:6:"0x2D30";i:1;s:6:"0x2D7F";i:2;s:8:"Tifinagh";}i:82;a:3:{i:0;s:6:"0x2D80";i:1;s:6:"0x2DDF";i:2;s:17:"Ethiopic Extended";}i:83;a:3:{i:0;s:6:"0x2E00";i:1;s:6:"0x2E7F";i:2;s:24:"Supplemental Punctuation";}i:84;a:3:{i:0;s:6:"0x2E80";i:1;s:6:"0x2EFF";i:2;s:23:"CJK Radicals Supplement";}i:85;a:3:{i:0;s:6:"0x2F00";i:1;s:6:"0x2FDF";i:2;s:15:"Kangxi Radicals";}i:86;a:3:{i:0;s:6:"0x2FF0";i:1;s:6:"0x2FFF";i:2;s:34:"Ideographic Description Characters";}i:87;a:3:{i:0;s:6:"0x3000";i:1;s:6:"0x303F";i:2;s:27:"CJK Symbols and Punctuation";}i:88;a:3:{i:0;s:6:"0x3040";i:1;s:6:"0x309F";i:2;s:8:"Hiragana";}i:89;a:3:{i:0;s:6:"0x30A0";i:1;s:6:"0x30FF";i:2;s:8:"Katakana";}i:90;a:3:{i:0;s:6:"0x3100";i:1;s:6:"0x312F";i:2;s:8:"Bopomofo";}i:91;a:3:{i:0;s:6:"0x3130";i:1;s:6:"0x318F";i:2;s:25:"Hangul Compatibility Jamo";}i:92;a:3:{i:0;s:6:"0x3190";i:1;s:6:"0x319F";i:2;s:6:"Kanbun";}i:93;a:3:{i:0;s:6:"0x31A0";i:1;s:6:"0x31BF";i:2;s:17:"Bopomofo Extended";}i:94;a:3:{i:0;s:6:"0x31C0";i:1;s:6:"0x31EF";i:2;s:11:"CJK Strokes";}i:95;a:3:{i:0;s:6:"0x31F0";i:1;s:6:"0x31FF";i:2;s:28:"Katakana Phonetic Extensions";}i:96;a:3:{i:0;s:6:"0x3200";i:1;s:6:"0x32FF";i:2;s:31:"Enclosed CJK Letters and Months";}i:97;a:3:{i:0;s:6:"0x3300";i:1;s:6:"0x33FF";i:2;s:17:"CJK Compatibility";}i:98;a:3:{i:0;s:6:"0x3400";i:1;s:6:"0x4DBF";i:2;s:34:"CJK Unified Ideographs Extension A";}i:99;a:3:{i:0;s:6:"0x4DC0";i:1;s:6:"0x4DFF";i:2;s:23:"Yijing Hexagram Symbols";}i:100;a:3:{i:0;s:6:"0x4E00";i:1;s:6:"0x9FFF";i:2;s:22:"CJK Unified Ideographs";}i:101;a:3:{i:0;s:6:"0xA000";i:1;s:6:"0xA48F";i:2;s:12:"Yi Syllables";}i:102;a:3:{i:0;s:6:"0xA490";i:1;s:6:"0xA4CF";i:2;s:11:"Yi Radicals";}i:103;a:3:{i:0;s:6:"0xA700";i:1;s:6:"0xA71F";i:2;s:21:"Modifier Tone Letters";}i:104;a:3:{i:0;s:6:"0xA800";i:1;s:6:"0xA82F";i:2;s:12:"Syloti Nagri";}i:105;a:3:{i:0;s:6:"0xAC00";i:1;s:6:"0xD7AF";i:2;s:16:"Hangul Syllables";}i:106;a:3:{i:0;s:6:"0xD800";i:1;s:6:"0xDB7F";i:2;s:15:"High Surrogates";}i:107;a:3:{i:0;s:6:"0xDB80";i:1;s:6:"0xDBFF";i:2;s:27:"High Private Use Surrogates";}i:108;a:3:{i:0;s:6:"0xDC00";i:1;s:6:"0xDFFF";i:2;s:14:"Low Surrogates";}i:109;a:3:{i:0;s:6:"0xE000";i:1;s:6:"0xF8FF";i:2;s:16:"Private Use Area";}i:110;a:3:{i:0;s:6:"0xF900";i:1;s:6:"0xFAFF";i:2;s:28:"CJK Compatibility Ideographs";}i:111;a:3:{i:0;s:6:"0xFB00";i:1;s:6:"0xFB4F";i:2;s:29:"Alphabetic Presentation Forms";}i:112;a:3:{i:0;s:6:"0xFB50";i:1;s:6:"0xFDFF";i:2;s:27:"Arabic Presentation Forms-A";}i:113;a:3:{i:0;s:6:"0xFE00";i:1;s:6:"0xFE0F";i:2;s:19:"Variation Selectors";}i:114;a:3:{i:0;s:6:"0xFE10";i:1;s:6:"0xFE1F";i:2;s:14:"Vertical Forms";}i:115;a:3:{i:0;s:6:"0xFE20";i:1;s:6:"0xFE2F";i:2;s:20:"Combining Half Marks";}i:116;a:3:{i:0;s:6:"0xFE30";i:1;s:6:"0xFE4F";i:2;s:23:"CJK Compatibility Forms";}i:117;a:3:{i:0;s:6:"0xFE50";i:1;s:6:"0xFE6F";i:2;s:19:"Small Form Variants";}i:118;a:3:{i:0;s:6:"0xFE70";i:1;s:6:"0xFEFF";i:2;s:27:"Arabic Presentation Forms-B";}i:119;a:3:{i:0;s:6:"0xFF00";i:1;s:6:"0xFFEF";i:2;s:29:"Halfwidth and Fullwidth Forms";}i:120;a:3:{i:0;s:6:"0xFFF0";i:1;s:6:"0xFFFF";i:2;s:8:"Specials";}i:121;a:3:{i:0;s:7:"0x10000";i:1;s:7:"0x1007F";i:2;s:18:"Linear B Syllabary";}i:122;a:3:{i:0;s:7:"0x10080";i:1;s:7:"0x100FF";i:2;s:18:"Linear B Ideograms";}i:123;a:3:{i:0;s:7:"0x10100";i:1;s:7:"0x1013F";i:2;s:14:"Aegean Numbers";}i:124;a:3:{i:0;s:7:"0x10140";i:1;s:7:"0x1018F";i:2;s:21:"Ancient Greek Numbers";}i:125;a:3:{i:0;s:7:"0x10300";i:1;s:7:"0x1032F";i:2;s:10:"Old Italic";}i:126;a:3:{i:0;s:7:"0x10330";i:1;s:7:"0x1034F";i:2;s:6:"Gothic";}i:127;a:3:{i:0;s:7:"0x10380";i:1;s:7:"0x1039F";i:2;s:8:"Ugaritic";}i:128;a:3:{i:0;s:7:"0x103A0";i:1;s:7:"0x103DF";i:2;s:11:"Old Persian";}i:129;a:3:{i:0;s:7:"0x10400";i:1;s:7:"0x1044F";i:2;s:7:"Deseret";}i:130;a:3:{i:0;s:7:"0x10450";i:1;s:7:"0x1047F";i:2;s:7:"Shavian";}i:131;a:3:{i:0;s:7:"0x10480";i:1;s:7:"0x104AF";i:2;s:7:"Osmanya";}i:132;a:3:{i:0;s:7:"0x10800";i:1;s:7:"0x1083F";i:2;s:17:"Cypriot Syllabary";}i:133;a:3:{i:0;s:7:"0x10A00";i:1;s:7:"0x10A5F";i:2;s:10:"Kharoshthi";}i:134;a:3:{i:0;s:7:"0x1D000";i:1;s:7:"0x1D0FF";i:2;s:25:"Byzantine Musical Symbols";}i:135;a:3:{i:0;s:7:"0x1D100";i:1;s:7:"0x1D1FF";i:2;s:15:"Musical Symbols";}i:136;a:3:{i:0;s:7:"0x1D200";i:1;s:7:"0x1D24F";i:2;s:30:"Ancient Greek Musical Notation";}i:137;a:3:{i:0;s:7:"0x1D300";i:1;s:7:"0x1D35F";i:2;s:21:"Tai Xuan Jing Symbols";}i:138;a:3:{i:0;s:7:"0x1D400";i:1;s:7:"0x1D7FF";i:2;s:33:"Mathematical Alphanumeric Symbols";}i:139;a:3:{i:0;s:7:"0x20000";i:1;s:7:"0x2A6DF";i:2;s:34:"CJK Unified Ideographs Extension B";}i:140;a:3:{i:0;s:7:"0x2F800";i:1;s:7:"0x2FA1F";i:2;s:39:"CJK Compatibility Ideographs Supplement";}i:141;a:3:{i:0;s:7:"0xE0000";i:1;s:7:"0xE007F";i:2;s:4:"Tags";}i:142;a:3:{i:0;s:7:"0xE0100";i:1;s:7:"0xE01EF";i:2;s:30:"Variation Selectors Supplement";}i:143;a:3:{i:0;s:7:"0xF0000";i:1;s:7:"0xFFFFF";i:2;s:32:"Supplementary Private Use Area-A";}i:144;a:3:{i:0;s:8:"0x100000";i:1;s:8:"0x10FFFF";i:2;s:32:"Supplementary Private Use Area-B";}}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/readability/JSLikeHTMLElement.php b/inc/3rdparty/libraries/readability/JSLikeHTMLElement.php
new file mode 100644
index 00000000..a8eeccf4
--- /dev/null
+++ b/inc/3rdparty/libraries/readability/JSLikeHTMLElement.php
@@ -0,0 +1,110 @@
+<?php

+/**

+* JavaScript-like HTML DOM Element

+*

+* This class extends PHP's DOMElement to allow

+* users to get and set the innerHTML property of

+* HTML elements in the same way it's done in 

+* JavaScript.

+*

+* Example usage:

+* @code

+* require_once 'JSLikeHTMLElement.php';

+* header('Content-Type: text/plain');

+* $doc = new DOMDocument();

+* $doc->registerNodeClass('DOMElement', 'JSLikeHTMLElement');

+* $doc->loadHTML('<div><p>Para 1</p><p>Para 2</p></div>');

+* $elem = $doc->getElementsByTagName('div')->item(0);

+* 

+* // print innerHTML

+* echo $elem->innerHTML; // prints '<p>Para 1</p><p>Para 2</p>'

+* echo "\n\n";

+* 

+* // set innerHTML

+* $elem->innerHTML = '<a href="http://fivefilters.org">FiveFilters.org</a>';

+* echo $elem->innerHTML; // prints '<a href="http://fivefilters.org">FiveFilters.org</a>'

+* echo "\n\n";

+* 

+* // print document (with our changes)

+* echo $doc->saveXML();

+* @endcode

+*

+* @author Keyvan Minoukadeh - http://www.keyvan.net - keyvan@keyvan.net

+* @see http://fivefilters.org (the project this was written for)

+*/

+class JSLikeHTMLElement extends DOMElement

+{

+        /**

+        * Used for setting innerHTML like it's done in JavaScript:

+        * @code

+        * $div->innerHTML = '<h2>Chapter 2</h2><p>The story begins...</p>';

+        * @endcode

+        */

+        public function __set($name, $value) {

+                if ($name == 'innerHTML') {

+                        // first, empty the element

+                        for ($x=$this->childNodes->length-1; $x>=0; $x--) {

+                                $this->removeChild($this->childNodes->item($x));

+                        }

+                        // $value holds our new inner HTML

+                        if ($value != '') {

+                                $f = $this->ownerDocument->createDocumentFragment();

+                                // appendXML() expects well-formed markup (XHTML)

+                                $result = @$f->appendXML($value); // @ to suppress PHP warnings

+                                if ($result) {

+                                        if ($f->hasChildNodes()) $this->appendChild($f);

+                                } else {

+                                        // $value is probably ill-formed

+                                        $f = new DOMDocument();

+                                        $value = mb_convert_encoding($value, 'HTML-ENTITIES', 'UTF-8');

+                                        // Using <htmlfragment> will generate a warning, but so will bad HTML

+                                        // (and by this point, bad HTML is what we've got).

+                                        // We use it (and suppress the warning) because an HTML fragment will 

+                                        // be wrapped around <html><body> tags which we don't really want to keep.

+                                        // Note: despite the warning, if loadHTML succeeds it will return true.

+                                        $result = @$f->loadHTML('<htmlfragment>'.$value.'</htmlfragment>');

+                                        if ($result) {

+                                                $import = $f->getElementsByTagName('htmlfragment')->item(0);

+                                                foreach ($import->childNodes as $child) {

+                                                        $importedNode = $this->ownerDocument->importNode($child, true);

+                                                        $this->appendChild($importedNode);

+                                                }

+                                        } else {

+                                                // oh well, we tried, we really did. :(

+                                                // this element is now empty

+                                        }

+                                }

+                        }

+                } else {

+                        $trace = debug_backtrace();

+                        trigger_error('Undefined property via __set(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_NOTICE);

+                }

+        }

+

+        /**

+        * Used for getting innerHTML like it's done in JavaScript:

+        * @code

+        * $string = $div->innerHTML;

+        * @endcode

+        */      

+        public function __get($name)

+        {

+                if ($name == 'innerHTML') {

+                        $inner = '';

+                        foreach ($this->childNodes as $child) {

+                                $inner .= $this->ownerDocument->saveXML($child);

+                        }

+                        return $inner;

+                }

+

+                $trace = debug_backtrace();

+                trigger_error('Undefined property via __get(): '.$name.' in '.$trace[0]['file'].' on line '.$trace[0]['line'], E_USER_NOTICE);

+                return null;

+        }

+

+        public function __toString()

+        {

+                return '['.$this->tagName.']';

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/readability/Readability.php b/inc/3rdparty/libraries/readability/Readability.php
new file mode 100644
index 00000000..2e8991cc
--- /dev/null
+++ b/inc/3rdparty/libraries/readability/Readability.php
@@ -0,0 +1,1138 @@
+<?php

+/** 

+* Arc90's Readability ported to PHP for FiveFilters.org

+* Based on readability.js version 1.7.1 (without multi-page support)

+* Updated to allow HTML5 parsing with html5lib

+* Updated with lightClean mode to preserve more images and youtube/vimeo/viddler embeds

+* ------------------------------------------------------

+* Original URL: http://lab.arc90.com/experiments/readability/js/readability.js

+* Arc90's project URL: http://lab.arc90.com/experiments/readability/

+* JS Source: http://code.google.com/p/arc90labs-readability

+* Ported by: Keyvan Minoukadeh, http://www.keyvan.net

+* More information: http://fivefilters.org/content-only/

+* License: Apache License, Version 2.0

+* Requires: PHP5

+* Date: 2012-09-19

+* 

+* Differences between the PHP port and the original

+* ------------------------------------------------------

+* Arc90's Readability is designed to run in the browser. It works on the DOM 

+* tree (the parsed HTML) after the page's CSS styles have been applied and 

+* Javascript code executed. This PHP port does not run inside a browser. 

+* We use PHP's ability to parse HTML to build our DOM tree, but we cannot 

+* rely on CSS or Javascript support. As such, the results will not always 

+* match Arc90's Readability. (For example, if a web page contains CSS style 

+* rules or Javascript code which hide certain HTML elements from display, 

+* Arc90's Readability will dismiss those from consideration but our PHP port, 

+* unable to understand CSS or Javascript, will not know any better.)

+* 

+* Another significant difference is that the aim of Arc90's Readability is 

+* to re-present the main content block of a given web page so users can 

+* read it more easily in their browsers. Correct identification, clean up, 

+* and separation of the content block is only a part of this process. 

+* This PHP port is only concerned with this part, it does not include code 

+* that relates to presentation in the browser - Arc90 already do 

+* that extremely well, and for PDF output there's FiveFilters.org's 

+* PDF Newspaper: http://fivefilters.org/pdf-newspaper/.

+* 

+* Finally, this class contains methods that might be useful for developers 

+* working on HTML document fragments. So without deviating too much from 

+* the original code (which I don't want to do because it makes debugging 

+* and updating more difficult), I've tried to make it a little more 

+* developer friendly. You should be able to use the methods here on 

+* existing DOMElement objects without passing an entire HTML document to 

+* be parsed.

+*/

+

+// This class allows us to do JavaScript like assignements to innerHTML

+require_once(dirname(__FILE__).'/JSLikeHTMLElement.php');

+

+// Alternative usage (for testing only!)

+// uncomment the lines below and call Readability.php in your browser 

+// passing it the URL of the page you'd like content from, e.g.:

+// Readability.php?url=http://medialens.org/alerts/09/090615_the_guardian_climate.php

+

+/*

+if (!isset($_GET['url']) || $_GET['url'] == '') {

+        die('Please pass a URL to the script. E.g. Readability.php?url=bla.com/story.html');

+}

+$url = $_GET['url'];

+if (!preg_match('!^https?://!i', $url)) $url = 'http://'.$url;

+$html = file_get_contents($url);

+$r = new Readability($html, $url);

+$r->init();

+echo $r->articleContent->innerHTML;

+*/

+

+class Readability

+{

+        public $version = '1.7.1-without-multi-page';

+        public $convertLinksToFootnotes = false;

+        public $revertForcedParagraphElements = true;

+        public $articleTitle;

+        public $articleContent;

+        public $dom;

+        public $url = null; // optional - URL where HTML was retrieved

+        public $debug = false;

+        public $lightClean = true; // preserves more content (experimental) added 2012-09-19

+        protected $body = null; // 

+        protected $bodyCache = null; // Cache the body HTML in case we need to re-use it later

+        protected $flags = 7; // 1 | 2 | 4;   // Start with all flags set.

+        protected $success = false; // indicates whether we were able to extract or not

+        

+        /**

+        * All of the regular expressions in use within readability.

+        * Defined up here so we don't instantiate them repeatedly in loops.

+        **/

+        public $regexps = array(

+                'unlikelyCandidates' => '/combx|comment|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup/i',

+                'okMaybeItsACandidate' => '/and|article|body|column|main|shadow/i',

+                'positive' => '/article|body|content|entry|hentry|main|page|attachment|pagination|post|text|blog|story/i',

+                'negative' => '/combx|comment|com-|contact|foot|footer|_nav|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget/i',

+                'divToPElements' => '/<(a|blockquote|dl|div|img|ol|p|pre|table|ul)/i',

+                'replaceBrs' => '/(<br[^>]*>[ \n\r\t]*){2,}/i',

+                'replaceFonts' => '/<(\/?)font[^>]*>/i',

+                // 'trimRe' => '/^\s+|\s+$/g', // PHP has trim()

+                'normalize' => '/\s{2,}/',

+                'killBreaks' => '/(<br\s*\/?>(\s|&nbsp;?)*){1,}/',

+                'video' => '!//(player\.|www\.)?(youtube|vimeo|viddler)\.com!i',

+                'skipFootnoteLink' => '/^\s*(\[?[a-z0-9]{1,2}\]?|^|edit|citation needed)\s*$/i'

+        );      

+        

+        /* constants */

+        const FLAG_STRIP_UNLIKELYS = 1;

+        const FLAG_WEIGHT_CLASSES = 2;

+        const FLAG_CLEAN_CONDITIONALLY = 4;

+        

+        /**

+        * Create instance of Readability

+        * @param string UTF-8 encoded string

+        * @param string (optional) URL associated with HTML (used for footnotes)

+        * @param string which parser to use for turning raw HTML into a DOMDocument (either 'libxml' or 'html5lib')

+        */      

+        function __construct($html, $url=null, $parser='libxml')

+        {

+                $this->url = $url;

+                /* Turn all double br's into p's */

+                $html = preg_replace($this->regexps['replaceBrs'], '</p><p>', $html);

+                $html = preg_replace($this->regexps['replaceFonts'], '<$1span>', $html);

+                $html = mb_convert_encoding($html, 'HTML-ENTITIES', "UTF-8");

+                if (trim($html) == '') $html = '<html></html>';

+                if ($parser=='html5lib' && ($this->dom = HTML5_Parser::parse($html))) {

+                        // all good

+                } else {

+                        $this->dom = new DOMDocument();

+                        $this->dom->preserveWhiteSpace = false;

+                        @$this->dom->loadHTML($html);

+                }

+                $this->dom->registerNodeClass('DOMElement', 'JSLikeHTMLElement');

+        }

+

+        /**

+        * Get article title element

+        * @return DOMElement

+        */

+        public function getTitle() {

+                return $this->articleTitle;

+        }

+        

+        /**

+        * Get article content element

+        * @return DOMElement

+        */

+        public function getContent() {

+                return $this->articleContent;

+        }       

+        

+        /**

+        * Runs readability.

+        * 

+        * Workflow:

+        *  1. Prep the document by removing script tags, css, etc.

+        *  2. Build readability's DOM tree.

+        *  3. Grab the article content from the current dom tree.

+        *  4. Replace the current DOM tree with the new one.

+        *  5. Read peacefully.

+        *

+        * @return boolean true if we found content, false otherwise

+        **/

+        public function init()

+        {

+                if (!isset($this->dom->documentElement)) return false;

+                $this->removeScripts($this->dom);

+                //die($this->getInnerHTML($this->dom->documentElement));

+                

+                // Assume successful outcome

+                $this->success = true;

+

+                $bodyElems = $this->dom->getElementsByTagName('body');

+                if ($bodyElems->length > 0) {

+                        if ($this->bodyCache == null) {

+                                $this->bodyCache = $bodyElems->item(0)->innerHTML;

+                        }

+                        if ($this->body == null) {

+                                $this->body = $bodyElems->item(0);

+                        }

+                }

+

+                $this->prepDocument();

+                

+                //die($this->dom->documentElement->parentNode->nodeType);

+                //$this->setInnerHTML($this->dom->documentElement, $this->getInnerHTML($this->dom->documentElement));

+                //die($this->getInnerHTML($this->dom->documentElement));

+

+                /* Build readability's DOM tree */

+                $overlay        = $this->dom->createElement('div');

+                $innerDiv       = $this->dom->createElement('div');

+                $articleTitle   = $this->getArticleTitle();

+                $articleContent = $this->grabArticle();

+

+                if (!$articleContent) {

+                        $this->success = false;

+                        $articleContent = $this->dom->createElement('div');

+                        $articleContent->setAttribute('id', 'readability-content');

+                        $articleContent->innerHTML = '<p>Sorry, Readability was unable to parse this page for content.</p>';            

+                }

+                

+                $overlay->setAttribute('id', 'readOverlay');

+                $innerDiv->setAttribute('id', 'readInner');

+

+                /* Glue the structure of our document together. */

+                $innerDiv->appendChild($articleTitle);

+                $innerDiv->appendChild($articleContent);

+                $overlay->appendChild($innerDiv);

+                

+                /* Clear the old HTML, insert the new content. */

+                $this->body->innerHTML = '';

+                $this->body->appendChild($overlay);

+                //document.body.insertBefore(overlay, document.body.firstChild);

+                $this->body->removeAttribute('style');

+

+                $this->postProcessContent($articleContent);

+                

+                // Set title and content instance variables

+                $this->articleTitle = $articleTitle;

+                $this->articleContent = $articleContent;

+                

+                return $this->success;

+        }

+        

+        /**

+        * Debug

+        */

+        protected function dbg($msg) {

+                if ($this->debug) echo '* ',$msg, "\n";

+        }

+        

+        /**

+        * Run any post-process modifications to article content as necessary.

+        *

+        * @param DOMElement

+        * @return void

+        */

+        public function postProcessContent($articleContent) {

+                if ($this->convertLinksToFootnotes && !preg_match('/wikipedia\.org/', @$this->url)) { 

+                        $this->addFootnotes($articleContent);

+                }

+        }

+        

+        /**

+        * Get the article title as an H1.

+        *

+        * @return DOMElement

+        */

+        protected function getArticleTitle() {

+                $curTitle = '';

+                $origTitle = '';

+

+                try {

+                        $curTitle = $origTitle = $this->getInnerText($this->dom->getElementsByTagName('title')->item(0));

+                } catch(Exception $e) {}

+                

+                if (preg_match('/ [\|\-] /', $curTitle))

+                {

+                        $curTitle = preg_replace('/(.*)[\|\-] .*/i', '$1', $origTitle);

+                        

+                        if (count(explode(' ', $curTitle)) < 3) {

+                                $curTitle = preg_replace('/[^\|\-]*[\|\-](.*)/i', '$1', $origTitle);

+                        }

+                }

+                else if (strpos($curTitle, ': ') !== false)

+                {

+                        $curTitle = preg_replace('/.*:(.*)/i', '$1', $origTitle);

+

+                        if (count(explode(' ', $curTitle)) < 3) {

+                                $curTitle = preg_replace('/[^:]*[:](.*)/i','$1', $origTitle);

+                        }

+                }

+                else if(strlen($curTitle) > 150 || strlen($curTitle) < 15)

+                {

+                        $hOnes = $this->dom->getElementsByTagName('h1');

+                        if($hOnes->length == 1)

+                        {

+                                $curTitle = $this->getInnerText($hOnes->item(0));

+                        }

+                }

+

+                $curTitle = trim($curTitle);

+

+                if (count(explode(' ', $curTitle)) <= 4) {

+                        $curTitle = $origTitle;

+                }

+                

+                $articleTitle = $this->dom->createElement('h1');

+                $articleTitle->innerHTML = $curTitle;

+                

+                return $articleTitle;

+        }

+        

+        /**

+        * Prepare the HTML document for readability to scrape it.

+        * This includes things like stripping javascript, CSS, and handling terrible markup.

+        * 

+        * @return void

+        **/

+        protected function prepDocument() {

+                /**

+                * In some cases a body element can't be found (if the HTML is totally hosed for example)

+                * so we create a new body node and append it to the document.

+                */

+                if ($this->body == null)

+                {

+                        $this->body = $this->dom->createElement('body');

+                        $this->dom->documentElement->appendChild($this->body);

+                }

+                $this->body->setAttribute('id', 'readabilityBody');

+

+                /* Remove all style tags in head */

+                $styleTags = $this->dom->getElementsByTagName('style');

+                for ($i = $styleTags->length-1; $i >= 0; $i--)

+                {

+                        $styleTags->item($i)->parentNode->removeChild($styleTags->item($i));

+                }

+

+                /* Turn all double br's into p's */

+                /* Note, this is pretty costly as far as processing goes. Maybe optimize later. */

+                //document.body.innerHTML = document.body.innerHTML.replace(readability.regexps.replaceBrs, '</p><p>').replace(readability.regexps.replaceFonts, '<$1span>');

+                // We do this in the constructor for PHP as that's when we have raw HTML - before parsing it into a DOM tree.

+                // Manipulating innerHTML as it's done in JS is not possible in PHP.

+        }

+

+        /**

+        * For easier reading, convert this document to have footnotes at the bottom rather than inline links.

+        * @see http://www.roughtype.com/archives/2010/05/experiments_in.php

+        *

+        * @return void

+        **/

+        public function addFootnotes($articleContent) {

+                $footnotesWrapper = $this->dom->createElement('div');

+                $footnotesWrapper->setAttribute('id', 'readability-footnotes');

+                $footnotesWrapper->innerHTML = '<h3>References</h3>';

+                

+                $articleFootnotes = $this->dom->createElement('ol');

+                $articleFootnotes->setAttribute('id', 'readability-footnotes-list');

+                $footnotesWrapper->appendChild($articleFootnotes);

+                

+                $articleLinks = $articleContent->getElementsByTagName('a');

+                

+                $linkCount = 0;

+                for ($i = 0; $i < $articleLinks->length; $i++)

+                {

+                        $articleLink  = $articleLinks->item($i);

+                        $footnoteLink = $articleLink->cloneNode(true);

+                        $refLink      = $this->dom->createElement('a');

+                        $footnote     = $this->dom->createElement('li');

+                        $linkDomain   = @parse_url($footnoteLink->getAttribute('href'), PHP_URL_HOST);

+                        if (!$linkDomain && isset($this->url)) $linkDomain = @parse_url($this->url, PHP_URL_HOST);

+                        //linkDomain   = footnoteLink.host ? footnoteLink.host : document.location.host,

+                        $linkText     = $this->getInnerText($articleLink);

+                        

+                        if ((strpos($articleLink->getAttribute('class'), 'readability-DoNotFootnote') !== false) || preg_match($this->regexps['skipFootnoteLink'], $linkText)) {

+                                continue;

+                        }

+                        

+                        $linkCount++;

+

+                        /** Add a superscript reference after the article link */

+                        $refLink->setAttribute('href', '#readabilityFootnoteLink-' . $linkCount);

+                        $refLink->innerHTML = '<small><sup>[' . $linkCount . ']</sup></small>';

+                        $refLink->setAttribute('class', 'readability-DoNotFootnote');

+                        $refLink->setAttribute('style', 'color: inherit;');

+                        

+                        //TODO: does this work or should we use DOMNode.isSameNode()?

+                        if ($articleLink->parentNode->lastChild == $articleLink) {

+                                $articleLink->parentNode->appendChild($refLink);

+                        } else {

+                                $articleLink->parentNode->insertBefore($refLink, $articleLink->nextSibling);

+                        }

+

+                        $articleLink->setAttribute('style', 'color: inherit; text-decoration: none;');

+                        $articleLink->setAttribute('name', 'readabilityLink-' . $linkCount);

+

+                        $footnote->innerHTML = '<small><sup><a href="#readabilityLink-' . $linkCount . '" title="Jump to Link in Article">^</a></sup></small> ';

+

+                        $footnoteLink->innerHTML = ($footnoteLink->getAttribute('title') != '' ? $footnoteLink->getAttribute('title') : $linkText);

+                        $footnoteLink->setAttribute('name', 'readabilityFootnoteLink-' . $linkCount);

+                        

+                        $footnote->appendChild($footnoteLink);

+                        if ($linkDomain) $footnote->innerHTML = $footnote->innerHTML . '<small> (' . $linkDomain . ')</small>';

+                        

+                        $articleFootnotes->appendChild($footnote);

+                }

+

+                if ($linkCount > 0) {

+                        $articleContent->appendChild($footnotesWrapper);           

+                }

+        }

+

+        /**

+        * Reverts P elements with class 'readability-styled'

+        * to text nodes - which is what they were before.

+        *

+        * @param DOMElement

+        * @return void

+        */

+        function revertReadabilityStyledElements($articleContent) {

+                $xpath = new DOMXPath($articleContent->ownerDocument);

+                $elems = $xpath->query('.//p[@class="readability-styled"]', $articleContent);

+                //$elems = $articleContent->getElementsByTagName('p');

+                for ($i = $elems->length-1; $i >= 0; $i--) {

+                        $e = $elems->item($i);

+                        $e->parentNode->replaceChild($articleContent->ownerDocument->createTextNode($e->textContent), $e);

+                        //if ($e->hasAttribute('class') && $e->getAttribute('class') == 'readability-styled') {

+                        //      $e->parentNode->replaceChild($this->dom->createTextNode($e->textContent), $e);

+                        //}

+                }

+        }

+        

+        /**

+        * Prepare the article node for display. Clean out any inline styles,

+        * iframes, forms, strip extraneous <p> tags, etc.

+        *

+        * @param DOMElement

+        * @return void

+        */

+        function prepArticle($articleContent) {

+                $this->cleanStyles($articleContent);

+                $this->killBreaks($articleContent);

+                if ($this->revertForcedParagraphElements) {

+                        $this->revertReadabilityStyledElements($articleContent);

+                }

+

+                /* Clean out junk from the article content */

+                $this->cleanConditionally($articleContent, 'form');

+                $this->clean($articleContent, 'object');

+                $this->clean($articleContent, 'h1');

+

+                /**

+                * If there is only one h2, they are probably using it

+                * as a header and not a subheader, so remove it since we already have a header.

+                ***/

+                if (!$this->lightClean && ($articleContent->getElementsByTagName('h2')->length == 1)) {

+                        $this->clean($articleContent, 'h2'); 

+                }

+                $this->clean($articleContent, 'iframe');

+

+                $this->cleanHeaders($articleContent);

+

+                /* Do these last as the previous stuff may have removed junk that will affect these */

+                $this->cleanConditionally($articleContent, 'table');

+                $this->cleanConditionally($articleContent, 'ul');

+                $this->cleanConditionally($articleContent, 'div');

+

+                /* Remove extra paragraphs */

+                $articleParagraphs = $articleContent->getElementsByTagName('p');

+                for ($i = $articleParagraphs->length-1; $i >= 0; $i--)

+                {

+                        $imgCount    = $articleParagraphs->item($i)->getElementsByTagName('img')->length;

+                        $embedCount  = $articleParagraphs->item($i)->getElementsByTagName('embed')->length;

+                        $objectCount = $articleParagraphs->item($i)->getElementsByTagName('object')->length;

+                        $iframeCount = $articleParagraphs->item($i)->getElementsByTagName('iframe')->length;

+                        

+                        if ($imgCount === 0 && $embedCount === 0 && $objectCount === 0 && $iframeCount === 0 && $this->getInnerText($articleParagraphs->item($i), false) == '')

+                        {

+                                $articleParagraphs->item($i)->parentNode->removeChild($articleParagraphs->item($i));

+                        }

+                }

+

+                try {

+                        $articleContent->innerHTML = preg_replace('/<br[^>]*>\s*<p/i', '<p', $articleContent->innerHTML);

+                        //articleContent.innerHTML = articleContent.innerHTML.replace(/<br[^>]*>\s*<p/gi, '<p');      

+                }

+                catch (Exception $e) {

+                        $this->dbg("Cleaning innerHTML of breaks failed. This is an IE strict-block-elements bug. Ignoring.: " . $e);

+                }

+        }

+        

+        /**

+        * Initialize a node with the readability object. Also checks the

+        * className/id for special names to add to its score.

+        *

+        * @param Element

+        * @return void

+        **/

+        protected function initializeNode($node) {

+                $readability = $this->dom->createAttribute('readability');

+                $readability->value = 0; // this is our contentScore

+                $node->setAttributeNode($readability);                   

+

+                switch (strtoupper($node->tagName)) { // unsure if strtoupper is needed, but using it just in case

+                        case 'DIV':

+                                $readability->value += 5;

+                                break;

+

+                        case 'PRE':

+                        case 'TD':

+                        case 'BLOCKQUOTE':

+                                $readability->value += 3;

+                                break;

+                                

+                        case 'ADDRESS':

+                        case 'OL':

+                        case 'UL':

+                        case 'DL':

+                        case 'DD':

+                        case 'DT':

+                        case 'LI':

+                        case 'FORM':

+                                $readability->value -= 3;

+                                break;

+

+                        case 'H1':

+                        case 'H2':

+                        case 'H3':

+                        case 'H4':

+                        case 'H5':

+                        case 'H6':

+                        case 'TH':

+                                $readability->value -= 5;

+                                break;

+                }

+                $readability->value += $this->getClassWeight($node);

+        }

+        

+        /***

+        * grabArticle - Using a variety of metrics (content score, classname, element types), find the content that is

+        *               most likely to be the stuff a user wants to read. Then return it wrapped up in a div.

+        *

+        * @return DOMElement

+        **/

+        protected function grabArticle($page=null) {

+                $stripUnlikelyCandidates = $this->flagIsActive(self::FLAG_STRIP_UNLIKELYS);

+                if (!$page) $page = $this->dom;

+                $allElements = $page->getElementsByTagName('*');

+                /**

+                * First, node prepping. Trash nodes that look cruddy (like ones with the class name "comment", etc), and turn divs

+                * into P tags where they have been used inappropriately (as in, where they contain no other block level elements.)

+                *

+                * Note: Assignment from index for performance. See http://www.peachpit.com/articles/article.aspx?p=31567&seqNum=5

+                * TODO: Shouldn't this be a reverse traversal?

+                **/

+                $node = null;

+                $nodesToScore = array();

+                for ($nodeIndex = 0; ($node = $allElements->item($nodeIndex)); $nodeIndex++) {

+                //for ($nodeIndex=$targetList->length-1; $nodeIndex >= 0; $nodeIndex--) {

+                        //$node = $targetList->item($nodeIndex);

+                        $tagName = strtoupper($node->tagName);

+                        /* Remove unlikely candidates */

+                        if ($stripUnlikelyCandidates) {

+                                $unlikelyMatchString = $node->getAttribute('class') . $node->getAttribute('id');

+                                if (

+                                        preg_match($this->regexps['unlikelyCandidates'], $unlikelyMatchString) &&

+                                        !preg_match($this->regexps['okMaybeItsACandidate'], $unlikelyMatchString) &&

+                                        $tagName != 'BODY'

+                                )

+                                {

+                                        $this->dbg('Removing unlikely candidate - ' . $unlikelyMatchString);

+                                        //$nodesToRemove[] = $node;

+                                        $node->parentNode->removeChild($node);

+                                        $nodeIndex--;

+                                        continue;

+                                }               

+                        }

+

+                        if ($tagName == 'P' || $tagName == 'TD' || $tagName == 'PRE') {

+                                $nodesToScore[] = $node;

+                        }

+

+                        /* Turn all divs that don't have children block level elements into p's */

+                        if ($tagName == 'DIV') {

+                                if (!preg_match($this->regexps['divToPElements'], $node->innerHTML)) {

+                                        //$this->dbg('Altering div to p');

+                                        $newNode = $this->dom->createElement('p');

+                                        try {

+                                                $newNode->innerHTML = $node->innerHTML;

+                                                //$nodesToReplace[] = array('new'=>$newNode, 'old'=>$node);

+                                                $node->parentNode->replaceChild($newNode, $node);

+                                                $nodeIndex--;

+                                                $nodesToScore[] = $node; // or $newNode?

+                                        }

+                                        catch(Exception $e) {

+                                                $this->dbg('Could not alter div to p, reverting back to div.: ' . $e);

+                                        }

+                                }

+                                else

+                                {

+                                        /* EXPERIMENTAL */

+                                        // TODO: change these p elements back to text nodes after processing

+                                        for ($i = 0, $il = $node->childNodes->length; $i < $il; $i++) {

+                                                $childNode = $node->childNodes->item($i);

+                                                if ($childNode->nodeType == 3) { // XML_TEXT_NODE

+                                                        //$this->dbg('replacing text node with a p tag with the same content.');

+                                                        $p = $this->dom->createElement('p');

+                                                        $p->innerHTML = $childNode->nodeValue;

+                                                        $p->setAttribute('style', 'display: inline;');

+                                                        $p->setAttribute('class', 'readability-styled');

+                                                        $childNode->parentNode->replaceChild($p, $childNode);

+                                                }

+                                        }

+                                }

+                        }

+                }

+                

+                /**

+                * Loop through all paragraphs, and assign a score to them based on how content-y they look.

+                * Then add their score to their parent node.

+                *

+                * A score is determined by things like number of commas, class names, etc. Maybe eventually link density.

+                **/

+                $candidates = array();

+                for ($pt=0; $pt < count($nodesToScore); $pt++) {

+                        $parentNode      = $nodesToScore[$pt]->parentNode;

+                        // $grandParentNode = $parentNode ? $parentNode->parentNode : null;

+                        $grandParentNode = !$parentNode ? null : (($parentNode->parentNode instanceof DOMElement) ? $parentNode->parentNode : null);

+                        $innerText       = $this->getInnerText($nodesToScore[$pt]);

+

+                        if (!$parentNode || !isset($parentNode->tagName)) {

+                                continue;

+                        }

+

+                        /* If this paragraph is less than 25 characters, don't even count it. */

+                        if(strlen($innerText) < 25) {

+                                continue;

+                        }

+

+                        /* Initialize readability data for the parent. */

+                        if (!$parentNode->hasAttribute('readability')) 

+                        {

+                                $this->initializeNode($parentNode);

+                                $candidates[] = $parentNode;

+                        }

+

+                        /* Initialize readability data for the grandparent. */

+                        if ($grandParentNode && !$grandParentNode->hasAttribute('readability') && isset($grandParentNode->tagName))

+                        {

+                                $this->initializeNode($grandParentNode);

+                                $candidates[] = $grandParentNode;

+                        }

+

+                        $contentScore = 0;

+

+                        /* Add a point for the paragraph itself as a base. */

+                        $contentScore++;

+

+                        /* Add points for any commas within this paragraph */

+                        $contentScore += count(explode(',', $innerText));

+                        

+                        /* For every 100 characters in this paragraph, add another point. Up to 3 points. */

+                        $contentScore += min(floor(strlen($innerText) / 100), 3);

+                        

+                        /* Add the score to the parent. The grandparent gets half. */

+                        $parentNode->getAttributeNode('readability')->value += $contentScore;

+

+                        if ($grandParentNode) {

+                                $grandParentNode->getAttributeNode('readability')->value += $contentScore/2;             

+                        }

+                }

+

+                /**

+                * After we've calculated scores, loop through all of the possible candidate nodes we found

+                * and find the one with the highest score.

+                **/

+                $topCandidate = null;

+                for ($c=0, $cl=count($candidates); $c < $cl; $c++)

+                {

+                        /**

+                        * Scale the final candidates score based on link density. Good content should have a

+                        * relatively small link density (5% or less) and be mostly unaffected by this operation.

+                        **/

+                        $readability = $candidates[$c]->getAttributeNode('readability');

+                        $readability->value = $readability->value * (1-$this->getLinkDensity($candidates[$c]));

+

+                        $this->dbg('Candidate: ' . $candidates[$c]->tagName . ' (' . $candidates[$c]->getAttribute('class') . ':' . $candidates[$c]->getAttribute('id') . ') with score ' . $readability->value);

+

+                        if (!$topCandidate || $readability->value > (int)$topCandidate->getAttribute('readability')) {

+                                $topCandidate = $candidates[$c];

+                        }

+                }

+

+                /**

+                * If we still have no top candidate, just use the body as a last resort.

+                * We also have to copy the body node so it is something we can modify.

+                **/

+                if ($topCandidate === null || strtoupper($topCandidate->tagName) == 'BODY')

+                {

+                        $topCandidate = $this->dom->createElement('div');

+                        if ($page instanceof DOMDocument) {

+                                if (!isset($page->documentElement)) {

+                                        // we don't have a body either? what a mess! :)

+                                } else {

+                                        $topCandidate->innerHTML = $page->documentElement->innerHTML;

+                                        $page->documentElement->innerHTML = '';

+                                        $page->documentElement->appendChild($topCandidate);

+                                }

+                        } else {

+                                $topCandidate->innerHTML = $page->innerHTML;

+                                $page->innerHTML = '';

+                                $page->appendChild($topCandidate);

+                        }

+                        $this->initializeNode($topCandidate);

+                }

+

+                /**

+                * Now that we have the top candidate, look through its siblings for content that might also be related.

+                * Things like preambles, content split by ads that we removed, etc.

+                **/

+                $articleContent        = $this->dom->createElement('div');

+                $articleContent->setAttribute('id', 'readability-content');

+                $siblingScoreThreshold = max(10, ((int)$topCandidate->getAttribute('readability')) * 0.2);

+                $siblingNodes          = $topCandidate->parentNode->childNodes;

+                if (!isset($siblingNodes)) {

+                        $siblingNodes = new stdClass;

+                        $siblingNodes->length = 0;

+                }

+

+                for ($s=0, $sl=$siblingNodes->length; $s < $sl; $s++)

+                {

+                        $siblingNode = $siblingNodes->item($s);

+                        $append      = false;

+

+                        $this->dbg('Looking at sibling node: ' . $siblingNode->nodeName . (($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('readability')) ? (' with score ' . $siblingNode->getAttribute('readability')) : ''));

+

+                        //dbg('Sibling has score ' . ($siblingNode->readability ? siblingNode.readability.contentScore : 'Unknown'));

+

+                        if ($siblingNode === $topCandidate)

+                        // or if ($siblingNode->isSameNode($topCandidate))

+                        {

+                                $append = true;

+                        }

+

+                        $contentBonus = 0;

+                        /* Give a bonus if sibling nodes and top candidates have the example same classname */

+                        if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->getAttribute('class') == $topCandidate->getAttribute('class') && $topCandidate->getAttribute('class') != '') {

+                                $contentBonus += ((int)$topCandidate->getAttribute('readability')) * 0.2;

+                        }

+

+                        if ($siblingNode->nodeType === XML_ELEMENT_NODE && $siblingNode->hasAttribute('readability') && (((int)$siblingNode->getAttribute('readability')) + $contentBonus) >= $siblingScoreThreshold)

+                        {

+                                $append = true;

+                        }

+                        

+                        if (strtoupper($siblingNode->nodeName) == 'P') {

+                                $linkDensity = $this->getLinkDensity($siblingNode);

+                                $nodeContent = $this->getInnerText($siblingNode);

+                                $nodeLength  = strlen($nodeContent);

+                                

+                                if ($nodeLength > 80 && $linkDensity < 0.25)

+                                {

+                                        $append = true;

+                                }

+                                else if ($nodeLength < 80 && $linkDensity === 0 && preg_match('/\.( |$)/', $nodeContent))

+                                {

+                                        $append = true;

+                                }

+                        }

+

+                        if ($append)

+                        {

+                                $this->dbg('Appending node: ' . $siblingNode->nodeName);

+

+                                $nodeToAppend = null;

+                                $sibNodeName = strtoupper($siblingNode->nodeName);

+                                if ($sibNodeName != 'DIV' && $sibNodeName != 'P') {

+                                        /* We have a node that isn't a common block level element, like a form or td tag. Turn it into a div so it doesn't get filtered out later by accident. */

+                                        

+                                        $this->dbg('Altering siblingNode of ' . $sibNodeName . ' to div.');

+                                        $nodeToAppend = $this->dom->createElement('div');

+                                        try {

+                                                $nodeToAppend->setAttribute('id', $siblingNode->getAttribute('id'));

+                                                $nodeToAppend->innerHTML = $siblingNode->innerHTML;

+                                        }

+                                        catch(Exception $e)

+                                        {

+                                                $this->dbg('Could not alter siblingNode to div, reverting back to original.');

+                                                $nodeToAppend = $siblingNode;

+                                                $s--;

+                                                $sl--;

+                                        }

+                                } else {

+                                        $nodeToAppend = $siblingNode;

+                                        $s--;

+                                        $sl--;

+                                }

+                                

+                                /* To ensure a node does not interfere with readability styles, remove its classnames */

+                                $nodeToAppend->removeAttribute('class');

+

+                                /* Append sibling and subtract from our list because it removes the node when you append to another node */

+                                $articleContent->appendChild($nodeToAppend);

+                        }

+                }

+

+                /**

+                * So we have all of the content that we need. Now we clean it up for presentation.

+                **/

+                $this->prepArticle($articleContent);

+

+                /**

+                * Now that we've gone through the full algorithm, check to see if we got any meaningful content.

+                * If we didn't, we may need to re-run grabArticle with different flags set. This gives us a higher

+                * likelihood of finding the content, and the sieve approach gives us a higher likelihood of

+                * finding the -right- content.

+                **/

+                if (strlen($this->getInnerText($articleContent, false)) < 250)

+                {

+                        // TODO: find out why element disappears sometimes, e.g. for this URL http://www.businessinsider.com/6-hedge-fund-etfs-for-average-investors-2011-7

+                        // in the meantime, we check and create an empty element if it's not there.

+                        if (!isset($this->body->childNodes)) $this->body = $this->dom->createElement('body');

+                        $this->body->innerHTML = $this->bodyCache;

+                        

+                        if ($this->flagIsActive(self::FLAG_STRIP_UNLIKELYS)) {

+                                $this->removeFlag(self::FLAG_STRIP_UNLIKELYS);

+                                return $this->grabArticle($this->body);

+                        }

+                        else if ($this->flagIsActive(self::FLAG_WEIGHT_CLASSES)) {

+                                $this->removeFlag(self::FLAG_WEIGHT_CLASSES);

+                                return $this->grabArticle($this->body);              

+                        }

+                        else if ($this->flagIsActive(self::FLAG_CLEAN_CONDITIONALLY)) {

+                                $this->removeFlag(self::FLAG_CLEAN_CONDITIONALLY);

+                                return $this->grabArticle($this->body);

+                        }

+                        else {

+                                return false;

+                        }

+                }

+                return $articleContent;

+        }

+        

+        /**

+        * Remove script tags from document

+        *

+        * @param DOMElement

+        * @return void

+        */

+        public function removeScripts($doc) {

+                $scripts = $doc->getElementsByTagName('script');

+                for($i = $scripts->length-1; $i >= 0; $i--)

+                {

+                        $scripts->item($i)->parentNode->removeChild($scripts->item($i));

+                }

+        }

+        

+        /**

+        * Get the inner text of a node.

+        * This also strips out any excess whitespace to be found.

+        *

+        * @param DOMElement $

+        * @param boolean $normalizeSpaces (default: true)

+        * @return string

+        **/

+        public function getInnerText($e, $normalizeSpaces=true) {

+                $textContent = '';

+

+                if (!isset($e->textContent) || $e->textContent == '') {

+                        return '';

+                }

+

+                $textContent = trim($e->textContent);

+

+                if ($normalizeSpaces) {

+                        return preg_replace($this->regexps['normalize'], ' ', $textContent);

+                } else {

+                        return $textContent;

+                }

+        }

+

+        /**

+        * Get the number of times a string $s appears in the node $e.

+        *

+        * @param DOMElement $e

+        * @param string - what to count. Default is ","

+        * @return number (integer)

+        **/

+        public function getCharCount($e, $s=',') {

+                return substr_count($this->getInnerText($e), $s);

+        }

+

+        /**

+        * Remove the style attribute on every $e and under.

+        *

+        * @param DOMElement $e

+        * @return void

+        */

+        public function cleanStyles($e) {

+                if (!is_object($e)) return;

+                $elems = $e->getElementsByTagName('*');

+                foreach ($elems as $elem) {

+                        $elem->removeAttribute('style');

+                }

+        }

+        

+        /**

+        * Get the density of links as a percentage of the content

+        * This is the amount of text that is inside a link divided by the total text in the node.

+        * 

+        * @param DOMElement $e

+        * @return number (float)

+        */

+        public function getLinkDensity($e) {

+                $links      = $e->getElementsByTagName('a');

+                $textLength = strlen($this->getInnerText($e));

+                $linkLength = 0;

+                for ($i=0, $il=$links->length; $i < $il; $i++)

+                {

+                        $linkLength += strlen($this->getInnerText($links->item($i)));

+                }

+                if ($textLength > 0) {

+                        return $linkLength / $textLength;

+                } else {

+                        return 0;

+                }

+        }

+        

+        /**

+        * Get an elements class/id weight. Uses regular expressions to tell if this 

+        * element looks good or bad.

+        *

+        * @param DOMElement $e

+        * @return number (Integer)

+        */

+        public function getClassWeight($e) {

+                if(!$this->flagIsActive(self::FLAG_WEIGHT_CLASSES)) {

+                        return 0;

+                }

+

+                $weight = 0;

+

+                /* Look for a special classname */

+                if ($e->hasAttribute('class') && $e->getAttribute('class') != '')

+                {

+                        if (preg_match($this->regexps['negative'], $e->getAttribute('class'))) {

+                                $weight -= 25;

+                        }

+                        if (preg_match($this->regexps['positive'], $e->getAttribute('class'))) {

+                                $weight += 25;

+                        }

+                }

+

+                /* Look for a special ID */

+                if ($e->hasAttribute('id') && $e->getAttribute('id') != '')

+                {

+                        if (preg_match($this->regexps['negative'], $e->getAttribute('id'))) {

+                                $weight -= 25;

+                        }

+                        if (preg_match($this->regexps['positive'], $e->getAttribute('id'))) {

+                                $weight += 25;

+                        }

+                }

+                return $weight;

+        }

+

+        /**

+        * Remove extraneous break tags from a node.

+        *

+        * @param DOMElement $node

+        * @return void

+        */

+        public function killBreaks($node) {

+                $html = $node->innerHTML;

+                $html = preg_replace($this->regexps['killBreaks'], '<br />', $html);

+                $node->innerHTML = $html;

+        }

+

+        /**

+        * Clean a node of all elements of type "tag".

+        * (Unless it's a youtube/vimeo video. People love movies.)

+        *

+        * Updated 2012-09-18 to preserve youtube/vimeo iframes

+        *

+        * @param DOMElement $e

+        * @param string $tag

+        * @return void

+        */

+        public function clean($e, $tag) {

+                $targetList = $e->getElementsByTagName($tag);

+                $isEmbed = ($tag == 'iframe' || $tag == 'object' || $tag == 'embed');

+                

+                for ($y=$targetList->length-1; $y >= 0; $y--) {

+                        /* Allow youtube and vimeo videos through as people usually want to see those. */

+                        if ($isEmbed) {

+                                $attributeValues = '';

+                                for ($i=0, $il=$targetList->item($y)->attributes->length; $i < $il; $i++) {

+                                        $attributeValues .= $targetList->item($y)->attributes->item($i)->value . '|'; // DOMAttr? (TODO: test)

+                                }

+                                

+                                /* First, check the elements attributes to see if any of them contain youtube or vimeo */

+                                if (preg_match($this->regexps['video'], $attributeValues)) {

+                                        continue;

+                                }

+

+                                /* Then check the elements inside this element for the same. */

+                                if (preg_match($this->regexps['video'], $targetList->item($y)->innerHTML)) {

+                                        continue;

+                                }

+                        }

+                        $targetList->item($y)->parentNode->removeChild($targetList->item($y));

+                }

+        }

+        

+        /**

+        * Clean an element of all tags of type "tag" if they look fishy.

+        * "Fishy" is an algorithm based on content length, classnames, 

+        * link density, number of images & embeds, etc.

+        *

+        * @param DOMElement $e

+        * @param string $tag

+        * @return void

+        */

+        public function cleanConditionally($e, $tag) {

+                if (!$this->flagIsActive(self::FLAG_CLEAN_CONDITIONALLY)) {

+                        return;

+                }

+

+                $tagsList = $e->getElementsByTagName($tag);

+                $curTagsLength = $tagsList->length;

+

+                /**

+                * Gather counts for other typical elements embedded within.

+                * Traverse backwards so we can remove nodes at the same time without effecting the traversal.

+                *

+                * TODO: Consider taking into account original contentScore here.

+                */

+                for ($i=$curTagsLength-1; $i >= 0; $i--) {

+                        $weight = $this->getClassWeight($tagsList->item($i));

+                        $contentScore = ($tagsList->item($i)->hasAttribute('readability')) ? (int)$tagsList->item($i)->getAttribute('readability') : 0;

+                        

+                        $this->dbg('Cleaning Conditionally ' . $tagsList->item($i)->tagName . ' (' . $tagsList->item($i)->getAttribute('class') . ':' . $tagsList->item($i)->getAttribute('id') . ')' . (($tagsList->item($i)->hasAttribute('readability')) ? (' with score ' . $tagsList->item($i)->getAttribute('readability')) : ''));

+

+                        if ($weight + $contentScore < 0) {

+                                $tagsList->item($i)->parentNode->removeChild($tagsList->item($i));

+                        }

+                        else if ( $this->getCharCount($tagsList->item($i), ',') < 10) {

+                                /**

+                                * If there are not very many commas, and the number of

+                                * non-paragraph elements is more than paragraphs or other ominous signs, remove the element.

+                                **/

+                                $p      = $tagsList->item($i)->getElementsByTagName('p')->length;

+                                $img    = $tagsList->item($i)->getElementsByTagName('img')->length;

+                                $li     = $tagsList->item($i)->getElementsByTagName('li')->length-100;

+                                $input  = $tagsList->item($i)->getElementsByTagName('input')->length;

+                                $a              = $tagsList->item($i)->getElementsByTagName('a')->length;

+

+                                $embedCount = 0;

+                                $embeds = $tagsList->item($i)->getElementsByTagName('embed');

+                                for ($ei=0, $il=$embeds->length; $ei < $il; $ei++) {

+                                        if (preg_match($this->regexps['video'], $embeds->item($ei)->getAttribute('src'))) {

+                                                $embedCount++; 

+                                        }

+                                }

+                                $embeds = $tagsList->item($i)->getElementsByTagName('iframe');

+                                for ($ei=0, $il=$embeds->length; $ei < $il; $ei++) {

+                                        if (preg_match($this->regexps['video'], $embeds->item($ei)->getAttribute('src'))) {

+                                                $embedCount++; 

+                                        }

+                                }

+

+                                $linkDensity   = $this->getLinkDensity($tagsList->item($i));

+                                $contentLength = strlen($this->getInnerText($tagsList->item($i)));

+                                $toRemove      = false;

+

+                                if ($this->lightClean) {

+                                        $this->dbg('Light clean...');

+                                        if ( ($img > $p) && ($img > 4) ) {

+                                                $this->dbg(' more than 4 images and more image elements than paragraph elements');

+                                                $toRemove = true;

+                                        } else if ($li > $p && $tag != 'ul' && $tag != 'ol') {

+                                                $this->dbg(' too many <li> elements, and parent is not <ul> or <ol>');

+                                                $toRemove = true;

+                                        } else if ( $input > floor($p/3) ) {

+                                                $this->dbg(' too many <input> elements');

+                                                $toRemove = true; 

+                                        } else if ($contentLength < 25 && ($embedCount === 0 && ($img === 0 || $img > 2))) {

+                                                $this->dbg(' content length less than 25 chars, 0 embeds and either 0 images or more than 2 images');

+                                                $toRemove = true;

+                                        } else if($weight < 25 && $linkDensity > 0.2) {

+                                                $this->dbg(' weight smaller than 25 and link density above 0.2');

+                                                $toRemove = true;

+                                        } else if($a > 2 && ($weight >= 25 && $linkDensity > 0.5)) {

+                                                $this->dbg(' more than 2 links and weight above 25 but link density greater than 0.5');

+                                                $toRemove = true;

+                                        } else if($embedCount > 3) {

+                                                $this->dbg(' more than 3 embeds');

+                                                $toRemove = true;

+                                        }

+                                } else {

+                                        $this->dbg('Standard clean...');

+                                        if ( $img > $p ) {

+                                                $this->dbg(' more image elements than paragraph elements');

+                                                $toRemove = true;

+                                        } else if ($li > $p && $tag != 'ul' && $tag != 'ol') {

+                                                $this->dbg(' too many <li> elements, and parent is not <ul> or <ol>');

+                                                $toRemove = true;

+                                        } else if ( $input > floor($p/3) ) {

+                                                $this->dbg(' too many <input> elements');

+                                                $toRemove = true; 

+                                        } else if ($contentLength < 25 && ($img === 0 || $img > 2) ) {

+                                                $this->dbg(' content length less than 25 chars and 0 images, or more than 2 images');

+                                                $toRemove = true;

+                                        } else if($weight < 25 && $linkDensity > 0.2) {

+                                                $this->dbg(' weight smaller than 25 and link density above 0.2');

+                                                $toRemove = true;

+                                        } else if($weight >= 25 && $linkDensity > 0.5) {

+                                                $this->dbg(' weight above 25 but link density greater than 0.5');

+                                                $toRemove = true;

+                                        } else if(($embedCount == 1 && $contentLength < 75) || $embedCount > 1) {

+                                                $this->dbg(' 1 embed and content length smaller than 75 chars, or more than one embed');

+                                                $toRemove = true;

+                                        }

+                                }

+

+                                if ($toRemove) {

+                                        //$this->dbg('Removing: '.$tagsList->item($i)->innerHTML);

+                                        $tagsList->item($i)->parentNode->removeChild($tagsList->item($i));

+                                }

+                        }

+                }

+        }

+

+        /**

+        * Clean out spurious headers from an Element. Checks things like classnames and link density.

+        *

+        * @param DOMElement $e

+        * @return void

+        */

+        public function cleanHeaders($e) {

+                for ($headerIndex = 1; $headerIndex < 3; $headerIndex++) {

+                        $headers = $e->getElementsByTagName('h' . $headerIndex);

+                        for ($i=$headers->length-1; $i >=0; $i--) {

+                                if ($this->getClassWeight($headers->item($i)) < 0 || $this->getLinkDensity($headers->item($i)) > 0.33) {

+                                        $headers->item($i)->parentNode->removeChild($headers->item($i));

+                                }

+                        }

+                }

+        }

+

+        public function flagIsActive($flag) {

+                return ($this->flags & $flag) > 0;

+        }

+        

+        public function addFlag($flag) {

+                $this->flags = $this->flags | $flag;

+        }

+        

+        public function removeFlag($flag) {

+                $this->flags = $this->flags & ~$flag;

+        }

+}

+?>
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/LICENSE.txt b/inc/3rdparty/libraries/simplepie/LICENSE.txt
new file mode 100644
index 00000000..a822a4bd
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/LICENSE.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2004-2007, Ryan Parman and Geoffrey Sneddon.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are 
+permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright notice, this list of 
+          conditions and the following disclaimer.
+
+        * Redistributions in binary form must reproduce the above copyright notice, this list 
+          of conditions and the following disclaimer in the documentation and/or other materials 
+          provided with the distribution.
+
+        * Neither the name of the SimplePie Team nor the names of its contributors may be used 
+          to endorse or promote products derived from this software without specific prior 
+          written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS 
+AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/autoloader.php b/inc/3rdparty/libraries/simplepie/autoloader.php
new file mode 100644
index 00000000..c16a8f8b
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/autoloader.php
@@ -0,0 +1,86 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2009, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+// autoloader
+spl_autoload_register(array(new SimplePie_Autoloader(), 'autoload'));
+
+if (!class_exists('SimplePie'))
+{
+        trigger_error('Autoloader not registered properly', E_USER_ERROR);
+}
+
+/**
+ * Autoloader class
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Autoloader
+{
+        /**
+         * Constructor
+         */
+        public function __construct()
+        {
+                $this->path = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'library';
+        }
+
+        /**
+         * Autoloader
+         *
+         * @param string $class The name of the class to attempt to load.
+         */
+        public function autoload($class)
+        {
+                // Only load the class if it starts with "SimplePie"
+                if (strpos($class, 'SimplePie') !== 0)
+                {
+                        return;
+                }
+
+                $filename = $this->path . DIRECTORY_SEPARATOR . str_replace('_', DIRECTORY_SEPARATOR, $class) . '.php';
+                include $filename;
+        }
+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie.php b/inc/3rdparty/libraries/simplepie/library/SimplePie.php
new file mode 100644
index 00000000..b33c635f
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie.php
@@ -0,0 +1,3058 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * SimplePie Name
+ */
+define('SIMPLEPIE_NAME', 'SimplePie');
+
+/**
+ * SimplePie Version
+ */
+define('SIMPLEPIE_VERSION', '1.3.1');
+
+/**
+ * SimplePie Build
+ * @todo Hardcode for release (there's no need to have to call SimplePie_Misc::get_build() only every load of simplepie.inc)
+ */
+define('SIMPLEPIE_BUILD', gmdate('YmdHis', SimplePie_Misc::get_build()));
+
+/**
+ * SimplePie Website URL
+ */
+define('SIMPLEPIE_URL', 'http://simplepie.org');
+
+/**
+ * SimplePie Useragent
+ * @see SimplePie::set_useragent()
+ */
+define('SIMPLEPIE_USERAGENT', SIMPLEPIE_NAME . '/' . SIMPLEPIE_VERSION . ' (Feed Parser; ' . SIMPLEPIE_URL . '; Allow like Gecko) Build/' . SIMPLEPIE_BUILD);
+
+/**
+ * SimplePie Linkback
+ */
+define('SIMPLEPIE_LINKBACK', '<a href="' . SIMPLEPIE_URL . '" title="' . SIMPLEPIE_NAME . ' ' . SIMPLEPIE_VERSION . '">' . SIMPLEPIE_NAME . '</a>');
+
+/**
+ * No Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_NONE', 0);
+
+/**
+ * Feed Link Element Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_AUTODISCOVERY', 1);
+
+/**
+ * Local Feed Extension Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_LOCAL_EXTENSION', 2);
+
+/**
+ * Local Feed Body Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_LOCAL_BODY', 4);
+
+/**
+ * Remote Feed Extension Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_REMOTE_EXTENSION', 8);
+
+/**
+ * Remote Feed Body Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_REMOTE_BODY', 16);
+
+/**
+ * All Feed Autodiscovery
+ * @see SimplePie::set_autodiscovery_level()
+ */
+define('SIMPLEPIE_LOCATOR_ALL', 31);
+
+/**
+ * No known feed type
+ */
+define('SIMPLEPIE_TYPE_NONE', 0);
+
+/**
+ * RSS 0.90
+ */
+define('SIMPLEPIE_TYPE_RSS_090', 1);
+
+/**
+ * RSS 0.91 (Netscape)
+ */
+define('SIMPLEPIE_TYPE_RSS_091_NETSCAPE', 2);
+
+/**
+ * RSS 0.91 (Userland)
+ */
+define('SIMPLEPIE_TYPE_RSS_091_USERLAND', 4);
+
+/**
+ * RSS 0.91 (both Netscape and Userland)
+ */
+define('SIMPLEPIE_TYPE_RSS_091', 6);
+
+/**
+ * RSS 0.92
+ */
+define('SIMPLEPIE_TYPE_RSS_092', 8);
+
+/**
+ * RSS 0.93
+ */
+define('SIMPLEPIE_TYPE_RSS_093', 16);
+
+/**
+ * RSS 0.94
+ */
+define('SIMPLEPIE_TYPE_RSS_094', 32);
+
+/**
+ * RSS 1.0
+ */
+define('SIMPLEPIE_TYPE_RSS_10', 64);
+
+/**
+ * RSS 2.0
+ */
+define('SIMPLEPIE_TYPE_RSS_20', 128);
+
+/**
+ * RDF-based RSS
+ */
+define('SIMPLEPIE_TYPE_RSS_RDF', 65);
+
+/**
+ * Non-RDF-based RSS (truly intended as syndication format)
+ */
+define('SIMPLEPIE_TYPE_RSS_SYNDICATION', 190);
+
+/**
+ * All RSS
+ */
+define('SIMPLEPIE_TYPE_RSS_ALL', 255);
+
+/**
+ * Atom 0.3
+ */
+define('SIMPLEPIE_TYPE_ATOM_03', 256);
+
+/**
+ * Atom 1.0
+ */
+define('SIMPLEPIE_TYPE_ATOM_10', 512);
+
+/**
+ * All Atom
+ */
+define('SIMPLEPIE_TYPE_ATOM_ALL', 768);
+
+/**
+ * All feed types
+ */
+define('SIMPLEPIE_TYPE_ALL', 1023);
+
+/**
+ * No construct
+ */
+define('SIMPLEPIE_CONSTRUCT_NONE', 0);
+
+/**
+ * Text construct
+ */
+define('SIMPLEPIE_CONSTRUCT_TEXT', 1);
+
+/**
+ * HTML construct
+ */
+define('SIMPLEPIE_CONSTRUCT_HTML', 2);
+
+/**
+ * XHTML construct
+ */
+define('SIMPLEPIE_CONSTRUCT_XHTML', 4);
+
+/**
+ * base64-encoded construct
+ */
+define('SIMPLEPIE_CONSTRUCT_BASE64', 8);
+
+/**
+ * IRI construct
+ */
+define('SIMPLEPIE_CONSTRUCT_IRI', 16);
+
+/**
+ * A construct that might be HTML
+ */
+define('SIMPLEPIE_CONSTRUCT_MAYBE_HTML', 32);
+
+/**
+ * All constructs
+ */
+define('SIMPLEPIE_CONSTRUCT_ALL', 63);
+
+/**
+ * Don't change case
+ */
+define('SIMPLEPIE_SAME_CASE', 1);
+
+/**
+ * Change to lowercase
+ */
+define('SIMPLEPIE_LOWERCASE', 2);
+
+/**
+ * Change to uppercase
+ */
+define('SIMPLEPIE_UPPERCASE', 4);
+
+/**
+ * PCRE for HTML attributes
+ */
+define('SIMPLEPIE_PCRE_HTML_ATTRIBUTE', '((?:[\x09\x0A\x0B\x0C\x0D\x20]+[^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3D\x3E]*(?:[\x09\x0A\x0B\x0C\x0D\x20]*=[\x09\x0A\x0B\x0C\x0D\x20]*(?:"(?:[^"]*)"|\'(?:[^\']*)\'|(?:[^\x09\x0A\x0B\x0C\x0D\x20\x22\x27\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x3E]*)?))?)*)[\x09\x0A\x0B\x0C\x0D\x20]*');
+
+/**
+ * PCRE for XML attributes
+ */
+define('SIMPLEPIE_PCRE_XML_ATTRIBUTE', '((?:\s+(?:(?:[^\s:]+:)?[^\s:]+)\s*=\s*(?:"(?:[^"]*)"|\'(?:[^\']*)\'))*)\s*');
+
+/**
+ * XML Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_XML', 'http://www.w3.org/XML/1998/namespace');
+
+/**
+ * Atom 1.0 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_ATOM_10', 'http://www.w3.org/2005/Atom');
+
+/**
+ * Atom 0.3 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_ATOM_03', 'http://purl.org/atom/ns#');
+
+/**
+ * RDF Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
+
+/**
+ * RSS 0.90 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_RSS_090', 'http://my.netscape.com/rdf/simple/0.9/');
+
+/**
+ * RSS 1.0 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_RSS_10', 'http://purl.org/rss/1.0/');
+
+/**
+ * RSS 1.0 Content Module Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT', 'http://purl.org/rss/1.0/modules/content/');
+
+/**
+ * RSS 2.0 Namespace
+ * (Stupid, I know, but I'm certain it will confuse people less with support.)
+ */
+define('SIMPLEPIE_NAMESPACE_RSS_20', '');
+
+/**
+ * DC 1.0 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_DC_10', 'http://purl.org/dc/elements/1.0/');
+
+/**
+ * DC 1.1 Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_DC_11', 'http://purl.org/dc/elements/1.1/');
+
+/**
+ * W3C Basic Geo (WGS84 lat/long) Vocabulary Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO', 'http://www.w3.org/2003/01/geo/wgs84_pos#');
+
+/**
+ * GeoRSS Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_GEORSS', 'http://www.georss.org/georss');
+
+/**
+ * Media RSS Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS', 'http://search.yahoo.com/mrss/');
+
+/**
+ * Wrong Media RSS Namespace. Caused by a long-standing typo in the spec.
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG', 'http://search.yahoo.com/mrss');
+
+/**
+ * Wrong Media RSS Namespace #2. New namespace introduced in Media RSS 1.5.
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2', 'http://video.search.yahoo.com/mrss');
+
+/**
+ * Wrong Media RSS Namespace #3. A possible typo of the Media RSS 1.5 namespace.
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3', 'http://video.search.yahoo.com/mrss/');
+
+/**
+ * Wrong Media RSS Namespace #4. New spec location after the RSS Advisory Board takes it over, but not a valid namespace.
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4', 'http://www.rssboard.org/media-rss');
+
+/**
+ * Wrong Media RSS Namespace #5. A possible typo of the RSS Advisory Board URL.
+ */
+define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5', 'http://www.rssboard.org/media-rss/');
+
+/**
+ * iTunes RSS Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_ITUNES', 'http://www.itunes.com/dtds/podcast-1.0.dtd');
+
+/**
+ * XHTML Namespace
+ */
+define('SIMPLEPIE_NAMESPACE_XHTML', 'http://www.w3.org/1999/xhtml');
+
+/**
+ * IANA Link Relations Registry
+ */
+define('SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY', 'http://www.iana.org/assignments/relation/');
+
+/**
+ * No file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_NONE', 0);
+
+/**
+ * Remote file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_REMOTE', 1);
+
+/**
+ * Local file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_LOCAL', 2);
+
+/**
+ * fsockopen() file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_FSOCKOPEN', 4);
+
+/**
+ * cURL file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_CURL', 8);
+
+/**
+ * file_get_contents() file source
+ */
+define('SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS', 16);
+
+
+
+/**
+ * SimplePie
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie
+{
+        /**
+         * @var array Raw data
+         * @access private
+         */
+        public $data = array();
+
+        /**
+         * @var mixed Error string
+         * @access private
+         */
+        public $error;
+
+        /**
+         * @var object Instance of SimplePie_Sanitize (or other class)
+         * @see SimplePie::set_sanitize_class()
+         * @access private
+         */
+        public $sanitize;
+
+        /**
+         * @var string SimplePie Useragent
+         * @see SimplePie::set_useragent()
+         * @access private
+         */
+        public $useragent = SIMPLEPIE_USERAGENT;
+
+        /**
+         * @var string Feed URL
+         * @see SimplePie::set_feed_url()
+         * @access private
+         */
+        public $feed_url;
+
+        /**
+         * @var object Instance of SimplePie_File to use as a feed
+         * @see SimplePie::set_file()
+         * @access private
+         */
+        public $file;
+
+        /**
+         * @var string Raw feed data
+         * @see SimplePie::set_raw_data()
+         * @access private
+         */
+        public $raw_data;
+
+        /**
+         * @var int Timeout for fetching remote files
+         * @see SimplePie::set_timeout()
+         * @access private
+         */
+        public $timeout = 10;
+
+        /**
+         * @var bool Forces fsockopen() to be used for remote files instead
+         * of cURL, even if a new enough version is installed
+         * @see SimplePie::force_fsockopen()
+         * @access private
+         */
+        public $force_fsockopen = false;
+
+        /**
+         * @var bool Force the given data/URL to be treated as a feed no matter what
+         * it appears like
+         * @see SimplePie::force_feed()
+         * @access private
+         */
+        public $force_feed = false;
+
+        /**
+         * @var bool Enable/Disable Caching
+         * @see SimplePie::enable_cache()
+         * @access private
+         */
+        public $cache = true;
+
+        /**
+         * @var int Cache duration (in seconds)
+         * @see SimplePie::set_cache_duration()
+         * @access private
+         */
+        public $cache_duration = 3600;
+
+        /**
+         * @var int Auto-discovery cache duration (in seconds)
+         * @see SimplePie::set_autodiscovery_cache_duration()
+         * @access private
+         */
+        public $autodiscovery_cache_duration = 604800; // 7 Days.
+
+        /**
+         * @var string Cache location (relative to executing script)
+         * @see SimplePie::set_cache_location()
+         * @access private
+         */
+        public $cache_location = './cache';
+
+        /**
+         * @var string Function that creates the cache filename
+         * @see SimplePie::set_cache_name_function()
+         * @access private
+         */
+        public $cache_name_function = 'md5';
+
+        /**
+         * @var bool Reorder feed by date descending
+         * @see SimplePie::enable_order_by_date()
+         * @access private
+         */
+        public $order_by_date = true;
+
+        /**
+         * @var mixed Force input encoding to be set to the follow value
+         * (false, or anything type-cast to false, disables this feature)
+         * @see SimplePie::set_input_encoding()
+         * @access private
+         */
+        public $input_encoding = false;
+
+        /**
+         * @var int Feed Autodiscovery Level
+         * @see SimplePie::set_autodiscovery_level()
+         * @access private
+         */
+        public $autodiscovery = SIMPLEPIE_LOCATOR_ALL;
+
+        /**
+         * Class registry object
+         *
+         * @var SimplePie_Registry
+         */
+        public $registry;
+
+        /**
+         * @var int Maximum number of feeds to check with autodiscovery
+         * @see SimplePie::set_max_checked_feeds()
+         * @access private
+         */
+        public $max_checked_feeds = 10;
+
+        /**
+         * @var array All the feeds found during the autodiscovery process
+         * @see SimplePie::get_all_discovered_feeds()
+         * @access private
+         */
+        public $all_discovered_feeds = array();
+
+        /**
+         * @var string Web-accessible path to the handler_image.php file.
+         * @see SimplePie::set_image_handler()
+         * @access private
+         */
+        public $image_handler = '';
+
+        /**
+         * @var array Stores the URLs when multiple feeds are being initialized.
+         * @see SimplePie::set_feed_url()
+         * @access private
+         */
+        public $multifeed_url = array();
+
+        /**
+         * @var array Stores SimplePie objects when multiple feeds initialized.
+         * @access private
+         */
+        public $multifeed_objects = array();
+
+        /**
+         * @var array Stores the get_object_vars() array for use with multifeeds.
+         * @see SimplePie::set_feed_url()
+         * @access private
+         */
+        public $config_settings = null;
+
+        /**
+         * @var integer Stores the number of items to return per-feed with multifeeds.
+         * @see SimplePie::set_item_limit()
+         * @access private
+         */
+        public $item_limit = 0;
+
+        /**
+         * @var array Stores the default attributes to be stripped by strip_attributes().
+         * @see SimplePie::strip_attributes()
+         * @access private
+         */
+        public $strip_attributes = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc');
+
+        /**
+         * @var array Stores the default tags to be stripped by strip_htmltags().
+         * @see SimplePie::strip_htmltags()
+         * @access private
+         */
+        public $strip_htmltags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style');
+
+        /**
+         * The SimplePie class contains feed level data and options
+         *
+         * To use SimplePie, create the SimplePie object with no parameters. You can
+         * then set configuration options using the provided methods. After setting
+         * them, you must initialise the feed using $feed->init(). At that point the
+         * object's methods and properties will be available to you.
+         *
+         * Previously, it was possible to pass in the feed URL along with cache
+         * options directly into the constructor. This has been removed as of 1.3 as
+         * it caused a lot of confusion.
+         *
+         * @since 1.0 Preview Release
+         */
+        public function __construct()
+        {
+                if (version_compare(PHP_VERSION, '5.2', '<'))
+                {
+                        trigger_error('PHP 4.x, 5.0 and 5.1 are no longer supported. Please upgrade to PHP 5.2 or newer.');
+                        die();
+                }
+
+                // Other objects, instances created here so we can set options on them
+                $this->sanitize = new SimplePie_Sanitize();
+                $this->registry = new SimplePie_Registry();
+
+                if (func_num_args() > 0)
+                {
+                        $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING;
+                        trigger_error('Passing parameters to the constructor is no longer supported. Please use set_feed_url(), set_cache_location(), and set_cache_location() directly.', $level);
+
+                        $args = func_get_args();
+                        switch (count($args)) {
+                                case 3:
+                                        $this->set_cache_duration($args[2]);
+                                case 2:
+                                        $this->set_cache_location($args[1]);
+                                case 1:
+                                        $this->set_feed_url($args[0]);
+                                        $this->init();
+                        }
+                }
+        }
+
+        /**
+         * Used for converting object to a string
+         */
+        public function __toString()
+        {
+                return md5(serialize($this->data));
+        }
+
+        /**
+         * Remove items that link back to this before destroying this object
+         */
+        public function __destruct()
+        {
+                if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode'))
+                {
+                        if (!empty($this->data['items']))
+                        {
+                                foreach ($this->data['items'] as $item)
+                                {
+                                        $item->__destruct();
+                                }
+                                unset($item, $this->data['items']);
+                        }
+                        if (!empty($this->data['ordered_items']))
+                        {
+                                foreach ($this->data['ordered_items'] as $item)
+                                {
+                                        $item->__destruct();
+                                }
+                                unset($item, $this->data['ordered_items']);
+                        }
+                }
+        }
+
+        /**
+         * Force the given data/URL to be treated as a feed
+         *
+         * This tells SimplePie to ignore the content-type provided by the server.
+         * Be careful when using this option, as it will also disable autodiscovery.
+         *
+         * @since 1.1
+         * @param bool $enable Force the given data/URL to be treated as a feed
+         */
+        public function force_feed($enable = false)
+        {
+                $this->force_feed = (bool) $enable;
+        }
+
+        /**
+         * Set the URL of the feed you want to parse
+         *
+         * This allows you to enter the URL of the feed you want to parse, or the
+         * website you want to try to use auto-discovery on. This takes priority
+         * over any set raw data.
+         *
+         * You can set multiple feeds to mash together by passing an array instead
+         * of a string for the $url. Remember that with each additional feed comes
+         * additional processing and resources.
+         *
+         * @since 1.0 Preview Release
+         * @see set_raw_data()
+         * @param string|array $url This is the URL (or array of URLs) that you want to parse.
+         */
+        public function set_feed_url($url)
+        {
+                $this->multifeed_url = array();
+                if (is_array($url))
+                {
+                        foreach ($url as $value)
+                        {
+                                $this->multifeed_url[] = $this->registry->call('Misc', 'fix_protocol', array($value, 1));
+                        }
+                }
+                else
+                {
+                        $this->feed_url = $this->registry->call('Misc', 'fix_protocol', array($url, 1));
+                }
+        }
+
+        /**
+         * Set an instance of {@see SimplePie_File} to use as a feed
+         *
+         * @param SimplePie_File &$file
+         * @return bool True on success, false on failure
+         */
+        public function set_file(&$file)
+        {
+                if ($file instanceof SimplePie_File)
+                {
+                        $this->feed_url = $file->url;
+                        $this->file =& $file;
+                        return true;
+                }
+                return false;
+        }
+
+        /**
+         * Set the raw XML data to parse
+         *
+         * Allows you to use a string of RSS/Atom data instead of a remote feed.
+         *
+         * If you have a feed available as a string in PHP, you can tell SimplePie
+         * to parse that data string instead of a remote feed. Any set feed URL
+         * takes precedence.
+         *
+         * @since 1.0 Beta 3
+         * @param string $data RSS or Atom data as a string.
+         * @see set_feed_url()
+         */
+        public function set_raw_data($data)
+        {
+                $this->raw_data = $data;
+        }
+
+        /**
+         * Set the the default timeout for fetching remote feeds
+         *
+         * This allows you to change the maximum time the feed's server to respond
+         * and send the feed back.
+         *
+         * @since 1.0 Beta 3
+         * @param int $timeout The maximum number of seconds to spend waiting to retrieve a feed.
+         */
+        public function set_timeout($timeout = 10)
+        {
+                $this->timeout = (int) $timeout;
+        }
+
+        /**
+         * Force SimplePie to use fsockopen() instead of cURL
+         *
+         * @since 1.0 Beta 3
+         * @param bool $enable Force fsockopen() to be used
+         */
+        public function force_fsockopen($enable = false)
+        {
+                $this->force_fsockopen = (bool) $enable;
+        }
+
+        /**
+         * Enable/disable caching in SimplePie.
+         *
+         * This option allows you to disable caching all-together in SimplePie.
+         * However, disabling the cache can lead to longer load times.
+         *
+         * @since 1.0 Preview Release
+         * @param bool $enable Enable caching
+         */
+        public function enable_cache($enable = true)
+        {
+                $this->cache = (bool) $enable;
+        }
+
+        /**
+         * Set the length of time (in seconds) that the contents of a feed will be
+         * cached
+         *
+         * @param int $seconds The feed content cache duration
+         */
+        public function set_cache_duration($seconds = 3600)
+        {
+                $this->cache_duration = (int) $seconds;
+        }
+
+        /**
+         * Set the length of time (in seconds) that the autodiscovered feed URL will
+         * be cached
+         *
+         * @param int $seconds The autodiscovered feed URL cache duration.
+         */
+        public function set_autodiscovery_cache_duration($seconds = 604800)
+        {
+                $this->autodiscovery_cache_duration = (int) $seconds;
+        }
+
+        /**
+         * Set the file system location where the cached files should be stored
+         *
+         * @param string $location The file system location.
+         */
+        public function set_cache_location($location = './cache')
+        {
+                $this->cache_location = (string) $location;
+        }
+
+        /**
+         * Set whether feed items should be sorted into reverse chronological order
+         *
+         * @param bool $enable Sort as reverse chronological order.
+         */
+        public function enable_order_by_date($enable = true)
+        {
+                $this->order_by_date = (bool) $enable;
+        }
+
+        /**
+         * Set the character encoding used to parse the feed
+         *
+         * This overrides the encoding reported by the feed, however it will fall
+         * back to the normal encoding detection if the override fails
+         *
+         * @param string $encoding Character encoding
+         */
+        public function set_input_encoding($encoding = false)
+        {
+                if ($encoding)
+                {
+                        $this->input_encoding = (string) $encoding;
+                }
+                else
+                {
+                        $this->input_encoding = false;
+                }
+        }
+
+        /**
+         * Set how much feed autodiscovery to do
+         *
+         * @see SIMPLEPIE_LOCATOR_NONE
+         * @see SIMPLEPIE_LOCATOR_AUTODISCOVERY
+         * @see SIMPLEPIE_LOCATOR_LOCAL_EXTENSION
+         * @see SIMPLEPIE_LOCATOR_LOCAL_BODY
+         * @see SIMPLEPIE_LOCATOR_REMOTE_EXTENSION
+         * @see SIMPLEPIE_LOCATOR_REMOTE_BODY
+         * @see SIMPLEPIE_LOCATOR_ALL
+         * @param int $level Feed Autodiscovery Level (level can be a combination of the above constants, see bitwise OR operator)
+         */
+        public function set_autodiscovery_level($level = SIMPLEPIE_LOCATOR_ALL)
+        {
+                $this->autodiscovery = (int) $level;
+        }
+
+        /**
+         * Get the class registry
+         *
+         * Use this to override SimplePie's default classes
+         * @see SimplePie_Registry
+         * @return SimplePie_Registry
+         */
+        public function &get_registry()
+        {
+                return $this->registry;
+        }
+
+        /**#@+
+         * Useful when you are overloading or extending SimplePie's default classes.
+         *
+         * @deprecated Use {@see get_registry()} instead
+         * @link http://php.net/manual/en/language.oop5.basic.php#language.oop5.basic.extends PHP5 extends documentation
+         * @param string $class Name of custom class
+         * @return boolean True on success, false otherwise
+         */
+        /**
+         * Set which class SimplePie uses for caching
+         */
+        public function set_cache_class($class = 'SimplePie_Cache')
+        {
+                return $this->registry->register('Cache', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for auto-discovery
+         */
+        public function set_locator_class($class = 'SimplePie_Locator')
+        {
+                return $this->registry->register('Locator', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for XML parsing
+         */
+        public function set_parser_class($class = 'SimplePie_Parser')
+        {
+                return $this->registry->register('Parser', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for remote file fetching
+         */
+        public function set_file_class($class = 'SimplePie_File')
+        {
+                return $this->registry->register('File', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for data sanitization
+         */
+        public function set_sanitize_class($class = 'SimplePie_Sanitize')
+        {
+                return $this->registry->register('Sanitize', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for handling feed items
+         */
+        public function set_item_class($class = 'SimplePie_Item')
+        {
+                return $this->registry->register('Item', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for handling author data
+         */
+        public function set_author_class($class = 'SimplePie_Author')
+        {
+                return $this->registry->register('Author', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for handling category data
+         */
+        public function set_category_class($class = 'SimplePie_Category')
+        {
+                return $this->registry->register('Category', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for feed enclosures
+         */
+        public function set_enclosure_class($class = 'SimplePie_Enclosure')
+        {
+                return $this->registry->register('Enclosure', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for `<media:text>` captions
+         */
+        public function set_caption_class($class = 'SimplePie_Caption')
+        {
+                return $this->registry->register('Caption', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for `<media:copyright>`
+         */
+        public function set_copyright_class($class = 'SimplePie_Copyright')
+        {
+                return $this->registry->register('Copyright', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for `<media:credit>`
+         */
+        public function set_credit_class($class = 'SimplePie_Credit')
+        {
+                return $this->registry->register('Credit', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for `<media:rating>`
+         */
+        public function set_rating_class($class = 'SimplePie_Rating')
+        {
+                return $this->registry->register('Rating', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for `<media:restriction>`
+         */
+        public function set_restriction_class($class = 'SimplePie_Restriction')
+        {
+                return $this->registry->register('Restriction', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses for content-type sniffing
+         */
+        public function set_content_type_sniffer_class($class = 'SimplePie_Content_Type_Sniffer')
+        {
+                return $this->registry->register('Content_Type_Sniffer', $class, true);
+        }
+
+        /**
+         * Set which class SimplePie uses item sources
+         */
+        public function set_source_class($class = 'SimplePie_Source')
+        {
+                return $this->registry->register('Source', $class, true);
+        }
+        /**#@-*/
+
+        /**
+         * Set the user agent string
+         *
+         * @param string $ua New user agent string.
+         */
+        public function set_useragent($ua = SIMPLEPIE_USERAGENT)
+        {
+                $this->useragent = (string) $ua;
+        }
+
+        /**
+         * Set callback function to create cache filename with
+         *
+         * @param mixed $function Callback function
+         */
+        public function set_cache_name_function($function = 'md5')
+        {
+                if (is_callable($function))
+                {
+                        $this->cache_name_function = $function;
+                }
+        }
+
+        /**
+         * Set options to make SP as fast as possible
+         *
+         * Forgoes a substantial amount of data sanitization in favor of speed. This
+         * turns SimplePie into a dumb parser of feeds.
+         *
+         * @param bool $set Whether to set them or not
+         */
+        public function set_stupidly_fast($set = false)
+        {
+                if ($set)
+                {
+                        $this->enable_order_by_date(false);
+                        $this->remove_div(false);
+                        $this->strip_comments(false);
+                        $this->strip_htmltags(false);
+                        $this->strip_attributes(false);
+                        $this->set_image_handler(false);
+                }
+        }
+
+        /**
+         * Set maximum number of feeds to check with autodiscovery
+         *
+         * @param int $max Maximum number of feeds to check
+         */
+        public function set_max_checked_feeds($max = 10)
+        {
+                $this->max_checked_feeds = (int) $max;
+        }
+
+        public function remove_div($enable = true)
+        {
+                $this->sanitize->remove_div($enable);
+        }
+
+        public function strip_htmltags($tags = '', $encode = null)
+        {
+                if ($tags === '')
+                {
+                        $tags = $this->strip_htmltags;
+                }
+                $this->sanitize->strip_htmltags($tags);
+                if ($encode !== null)
+                {
+                        $this->sanitize->encode_instead_of_strip($tags);
+                }
+        }
+
+        public function encode_instead_of_strip($enable = true)
+        {
+                $this->sanitize->encode_instead_of_strip($enable);
+        }
+
+        public function strip_attributes($attribs = '')
+        {
+                if ($attribs === '')
+                {
+                        $attribs = $this->strip_attributes;
+                }
+                $this->sanitize->strip_attributes($attribs);
+        }
+
+        /**
+         * Set the output encoding
+         *
+         * Allows you to override SimplePie's output to match that of your webpage.
+         * This is useful for times when your webpages are not being served as
+         * UTF-8.  This setting will be obeyed by {@see handle_content_type()}, and
+         * is similar to {@see set_input_encoding()}.
+         *
+         * It should be noted, however, that not all character encodings can support
+         * all characters.  If your page is being served as ISO-8859-1 and you try
+         * to display a Japanese feed, you'll likely see garbled characters.
+         * Because of this, it is highly recommended to ensure that your webpages
+         * are served as UTF-8.
+         *
+         * The number of supported character encodings depends on whether your web
+         * host supports {@link http://php.net/mbstring mbstring},
+         * {@link http://php.net/iconv iconv}, or both. See
+         * {@link http://simplepie.org/wiki/faq/Supported_Character_Encodings} for
+         * more information.
+         *
+         * @param string $encoding
+         */
+        public function set_output_encoding($encoding = 'UTF-8')
+        {
+                $this->sanitize->set_output_encoding($encoding);
+        }
+
+        public function strip_comments($strip = false)
+        {
+                $this->sanitize->strip_comments($strip);
+        }
+
+        /**
+         * Set element/attribute key/value pairs of HTML attributes
+         * containing URLs that need to be resolved relative to the feed
+         *
+         * Defaults to |a|@href, |area|@href, |blockquote|@cite, |del|@cite,
+         * |form|@action, |img|@longdesc, |img|@src, |input|@src, |ins|@cite,
+         * |q|@cite
+         *
+         * @since 1.0
+         * @param array|null $element_attribute Element/attribute key/value pairs, null for default
+         */
+        public function set_url_replacements($element_attribute = null)
+        {
+                $this->sanitize->set_url_replacements($element_attribute);
+        }
+
+        /**
+         * Set the handler to enable the display of cached images.
+         *
+         * @param str $page Web-accessible path to the handler_image.php file.
+         * @param str $qs The query string that the value should be passed to.
+         */
+        public function set_image_handler($page = false, $qs = 'i')
+        {
+                if ($page !== false)
+                {
+                        $this->sanitize->set_image_handler($page . '?' . $qs . '=');
+                }
+                else
+                {
+                        $this->image_handler = '';
+                }
+        }
+
+        /**
+         * Set the limit for items returned per-feed with multifeeds
+         *
+         * @param integer $limit The maximum number of items to return.
+         */
+        public function set_item_limit($limit = 0)
+        {
+                $this->item_limit = (int) $limit;
+        }
+
+        /**
+         * Initialize the feed object
+         *
+         * This is what makes everything happen.  Period.  This is where all of the
+         * configuration options get processed, feeds are fetched, cached, and
+         * parsed, and all of that other good stuff.
+         *
+         * @return boolean True if successful, false otherwise
+         */
+        public function init()
+        {
+                // Check absolute bare minimum requirements.
+                if (!extension_loaded('xml') || !extension_loaded('pcre'))
+                {
+                        return false;
+                }
+                // Then check the xml extension is sane (i.e., libxml 2.7.x issue on PHP < 5.2.9 and libxml 2.7.0 to 2.7.2 on any version) if we don't have xmlreader.
+                elseif (!extension_loaded('xmlreader'))
+                {
+                        static $xml_is_sane = null;
+                        if ($xml_is_sane === null)
+                        {
+                                $parser_check = xml_parser_create();
+                                xml_parse_into_struct($parser_check, '<foo>&amp;</foo>', $values);
+                                xml_parser_free($parser_check);
+                                $xml_is_sane = isset($values[0]['value']);
+                        }
+                        if (!$xml_is_sane)
+                        {
+                                return false;
+                        }
+                }
+
+                if (method_exists($this->sanitize, 'set_registry'))
+                {
+                        $this->sanitize->set_registry($this->registry);
+                }
+
+                // Pass whatever was set with config options over to the sanitizer.
+                // Pass the classes in for legacy support; new classes should use the registry instead
+                $this->sanitize->pass_cache_data($this->cache, $this->cache_location, $this->cache_name_function, $this->registry->get_class('Cache'));
+                $this->sanitize->pass_file_data($this->registry->get_class('File'), $this->timeout, $this->useragent, $this->force_fsockopen);
+
+                if (!empty($this->multifeed_url))
+                {
+                        $i = 0;
+                        $success = 0;
+                        $this->multifeed_objects = array();
+                        $this->error = array();
+                        foreach ($this->multifeed_url as $url)
+                        {
+                                $this->multifeed_objects[$i] = clone $this;
+                                $this->multifeed_objects[$i]->set_feed_url($url);
+                                $single_success = $this->multifeed_objects[$i]->init();
+                                $success |= $single_success;
+                                if (!$single_success)
+                                {
+                                        $this->error[$i] = $this->multifeed_objects[$i]->error();
+                                }
+                                $i++;
+                        }
+                        return (bool) $success;
+                }
+                elseif ($this->feed_url === null && $this->raw_data === null)
+                {
+                        return false;
+                }
+
+                $this->error = null;
+                $this->data = array();
+                $this->multifeed_objects = array();
+                $cache = false;
+
+                if ($this->feed_url !== null)
+                {
+                        $parsed_feed_url = $this->registry->call('Misc', 'parse_url', array($this->feed_url));
+
+                        // Decide whether to enable caching
+                        if ($this->cache && $parsed_feed_url['scheme'] !== '')
+                        {
+                                $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $this->feed_url), 'spc'));
+                        }
+
+                        // Fetch the data via SimplePie_File into $this->raw_data
+                        if (($fetched = $this->fetch_data($cache)) === true)
+                        {
+                                return true;
+                        }
+                        elseif ($fetched === false) {
+                                return false;
+                        }
+
+                        list($headers, $sniffed) = $fetched;
+                }
+
+                // Set up array of possible encodings
+                $encodings = array();
+
+                // First check to see if input has been overridden.
+                if ($this->input_encoding !== false)
+                {
+                        $encodings[] = $this->input_encoding;
+                }
+
+                $application_types = array('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity');
+                $text_types = array('text/xml', 'text/xml-external-parsed-entity');
+
+                // RFC 3023 (only applies to sniffed content)
+                if (isset($sniffed))
+                {
+                        if (in_array($sniffed, $application_types) || substr($sniffed, 0, 12) === 'application/' && substr($sniffed, -4) === '+xml')
+                        {
+                                if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset))
+                                {
+                                        $encodings[] = strtoupper($charset[1]);
+                                }
+                                $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry)));
+                                $encodings[] = 'UTF-8';
+                        }
+                        elseif (in_array($sniffed, $text_types) || substr($sniffed, 0, 5) === 'text/' && substr($sniffed, -4) === '+xml')
+                        {
+                                if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset))
+                                {
+                                        $encodings[] = $charset[1];
+                                }
+                                $encodings[] = 'US-ASCII';
+                        }
+                        // Text MIME-type default
+                        elseif (substr($sniffed, 0, 5) === 'text/')
+                        {
+                                $encodings[] = 'US-ASCII';
+                        }
+                }
+
+                // Fallback to XML 1.0 Appendix F.1/UTF-8/ISO-8859-1
+                $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry)));
+                $encodings[] = 'UTF-8';
+                $encodings[] = 'ISO-8859-1';
+
+                // There's no point in trying an encoding twice
+                $encodings = array_unique($encodings);
+
+                // Loop through each possible encoding, till we return something, or run out of possibilities
+                foreach ($encodings as $encoding)
+                {
+                        // Change the encoding to UTF-8 (as we always use UTF-8 internally)
+                        if ($utf8_data = $this->registry->call('Misc', 'change_encoding', array($this->raw_data, $encoding, 'UTF-8')))
+                        {
+                                // Create new parser
+                                $parser = $this->registry->create('Parser');
+
+                                // If it's parsed fine
+                                if ($parser->parse($utf8_data, 'UTF-8'))
+                                {
+                                        $this->data = $parser->get_data();
+                                        if (!($this->get_type() & ~SIMPLEPIE_TYPE_NONE))
+                                        {
+                                                $this->error = "A feed could not be found at $this->feed_url. This does not appear to be a valid RSS or Atom feed.";
+                                                $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__));
+                                                return false;
+                                        }
+
+                                        if (isset($headers))
+                                        {
+                                                $this->data['headers'] = $headers;
+                                        }
+                                        $this->data['build'] = SIMPLEPIE_BUILD;
+
+                                        // Cache the file if caching is enabled
+                                        if ($cache && !$cache->save($this))
+                                        {
+                                                trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING);
+                                        }
+                                        return true;
+                                }
+                        }
+                }
+
+                if (isset($parser))
+                {
+                        // We have an error, just set SimplePie_Misc::error to it and quit
+                        $this->error = sprintf('This XML document is invalid, likely due to invalid characters. XML error: %s at line %d, column %d', $parser->get_error_string(), $parser->get_current_line(), $parser->get_current_column());
+                }
+                else
+                {
+                        $this->error = 'The data could not be converted to UTF-8. You MUST have either the iconv or mbstring extension installed. Upgrading to PHP 5.x (which includes iconv) is highly recommended.';
+                }
+
+                $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__));
+
+                return false;
+        }
+
+        /**
+         * Fetch the data via SimplePie_File
+         *
+         * If the data is already cached, attempt to fetch it from there instead
+         * @param SimplePie_Cache|false $cache Cache handler, or false to not load from the cache
+         * @return array|true Returns true if the data was loaded from the cache, or an array of HTTP headers and sniffed type
+         */
+        protected function fetch_data(&$cache)
+        {
+                // If it's enabled, use the cache
+                if ($cache)
+                {
+                        // Load the Cache
+                        $this->data = $cache->load();
+                        if (!empty($this->data))
+                        {
+                                // If the cache is for an outdated build of SimplePie
+                                if (!isset($this->data['build']) || $this->data['build'] !== SIMPLEPIE_BUILD)
+                                {
+                                        $cache->unlink();
+                                        $this->data = array();
+                                }
+                                // If we've hit a collision just rerun it with caching disabled
+                                elseif (isset($this->data['url']) && $this->data['url'] !== $this->feed_url)
+                                {
+                                        $cache = false;
+                                        $this->data = array();
+                                }
+                                // If we've got a non feed_url stored (if the page isn't actually a feed, or is a redirect) use that URL.
+                                elseif (isset($this->data['feed_url']))
+                                {
+                                        // If the autodiscovery cache is still valid use it.
+                                        if ($cache->mtime() + $this->autodiscovery_cache_duration > time())
+                                        {
+                                                // Do not need to do feed autodiscovery yet.
+                                                if ($this->data['feed_url'] !== $this->data['url'])
+                                                {
+                                                        $this->set_feed_url($this->data['feed_url']);
+                                                        return $this->init();
+                                                }
+
+                                                $cache->unlink();
+                                                $this->data = array();
+                                        }
+                                }
+                                // Check if the cache has been updated
+                                elseif ($cache->mtime() + $this->cache_duration < time())
+                                {
+                                        // If we have last-modified and/or etag set
+                                        if (isset($this->data['headers']['last-modified']) || isset($this->data['headers']['etag']))
+                                        {
+                                                $headers = array(
+                                                        'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',
+                                                );
+                                                if (isset($this->data['headers']['last-modified']))
+                                                {
+                                                        $headers['if-modified-since'] = $this->data['headers']['last-modified'];
+                                                }
+                                                if (isset($this->data['headers']['etag']))
+                                                {
+                                                        $headers['if-none-match'] = $this->data['headers']['etag'];
+                                                }
+
+                                                $file = $this->registry->create('File', array($this->feed_url, $this->timeout/10, 5, $headers, $this->useragent, $this->force_fsockopen));
+
+                                                if ($file->success)
+                                                {
+                                                        if ($file->status_code === 304)
+                                                        {
+                                                                $cache->touch();
+                                                                return true;
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        unset($file);
+                                                }
+                                        }
+                                }
+                                // If the cache is still valid, just return true
+                                else
+                                {
+                                        $this->raw_data = false;
+                                        return true;
+                                }
+                        }
+                        // If the cache is empty, delete it
+                        else
+                        {
+                                $cache->unlink();
+                                $this->data = array();
+                        }
+                }
+                // If we don't already have the file (it'll only exist if we've opened it to check if the cache has been modified), open it.
+                if (!isset($file))
+                {
+                        if ($this->file instanceof SimplePie_File && $this->file->url === $this->feed_url)
+                        {
+                                $file =& $this->file;
+                        }
+                        else
+                        {
+                                $headers = array(
+                                        'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',
+                                );
+                                $file = $this->registry->create('File', array($this->feed_url, $this->timeout, 5, $headers, $this->useragent, $this->force_fsockopen));
+                        }
+                }
+                // If the file connection has an error, set SimplePie::error to that and quit
+                if (!$file->success && !($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($file->status_code === 200 || $file->status_code > 206 && $file->status_code < 300)))
+                {
+                        $this->error = $file->error;
+                        return !empty($this->data);
+                }
+
+                if (!$this->force_feed)
+                {
+                        // Check if the supplied URL is a feed, if it isn't, look for it.
+                        $locate = $this->registry->create('Locator', array(&$file, $this->timeout, $this->useragent, $this->max_checked_feeds));
+
+                        if (!$locate->is_feed($file))
+                        {
+                                // We need to unset this so that if SimplePie::set_file() has been called that object is untouched
+                                unset($file);
+                                try
+                                {
+                                        if (!($file = $locate->find($this->autodiscovery, $this->all_discovered_feeds)))
+                                        {
+                                                $this->error = "A feed could not be found at $this->feed_url. A feed with an invalid mime type may fall victim to this error, or " . SIMPLEPIE_NAME . " was unable to auto-discover it.. Use force_feed() if you are certain this URL is a real feed.";
+                                                $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__));
+                                                return false;
+                                        }
+                                }
+                                catch (SimplePie_Exception $e)
+                                {
+                                        // This is usually because DOMDocument doesn't exist
+                                        $this->error = $e->getMessage();
+                                        $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, $e->getFile(), $e->getLine()));
+                                        return false;
+                                }
+                                if ($cache)
+                                {
+                                        $this->data = array('url' => $this->feed_url, 'feed_url' => $file->url, 'build' => SIMPLEPIE_BUILD);
+                                        if (!$cache->save($this))
+                                        {
+                                                trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING);
+                                        }
+                                        $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $file->url), 'spc'));
+                                }
+                                $this->feed_url = $file->url;
+                        }
+                        $locate = null;
+                }
+
+                $this->raw_data = $file->body;
+
+                $headers = $file->headers;
+                $sniffer = $this->registry->create('Content_Type_Sniffer', array(&$file));
+                $sniffed = $sniffer->get_type();
+
+                return array($headers, $sniffed);
+        }
+
+        /**
+         * Get the error message for the occured error
+         *
+         * @return string|array Error message, or array of messages for multifeeds
+         */
+        public function error()
+        {
+                return $this->error;
+        }
+
+        /**
+         * Get the raw XML
+         *
+         * This is the same as the old `$feed->enable_xml_dump(true)`, but returns
+         * the data instead of printing it.
+         *
+         * @return string|boolean Raw XML data, false if the cache is used
+         */
+        public function get_raw_data()
+        {
+                return $this->raw_data;
+        }
+
+        /**
+         * Get the character encoding used for output
+         *
+         * @since Preview Release
+         * @return string
+         */
+        public function get_encoding()
+        {
+                return $this->sanitize->output_encoding;
+        }
+
+        /**
+         * Send the content-type header with correct encoding
+         *
+         * This method ensures that the SimplePie-enabled page is being served with
+         * the correct {@link http://www.iana.org/assignments/media-types/ mime-type}
+         * and character encoding HTTP headers (character encoding determined by the
+         * {@see set_output_encoding} config option).
+         *
+         * This won't work properly if any content or whitespace has already been
+         * sent to the browser, because it relies on PHP's
+         * {@link http://php.net/header header()} function, and these are the
+         * circumstances under which the function works.
+         *
+         * Because it's setting these settings for the entire page (as is the nature
+         * of HTTP headers), this should only be used once per page (again, at the
+         * top).
+         *
+         * @param string $mime MIME type to serve the page as
+         */
+        public function handle_content_type($mime = 'text/html')
+        {
+                if (!headers_sent())
+                {
+                        $header = "Content-type: $mime;";
+                        if ($this->get_encoding())
+                        {
+                                $header .= ' charset=' . $this->get_encoding();
+                        }
+                        else
+                        {
+                                $header .= ' charset=UTF-8';
+                        }
+                        header($header);
+                }
+        }
+
+        /**
+         * Get the type of the feed
+         *
+         * This returns a SIMPLEPIE_TYPE_* constant, which can be tested against
+         * using {@link http://php.net/language.operators.bitwise bitwise operators}
+         *
+         * @since 0.8 (usage changed to using constants in 1.0)
+         * @see SIMPLEPIE_TYPE_NONE Unknown.
+         * @see SIMPLEPIE_TYPE_RSS_090 RSS 0.90.
+         * @see SIMPLEPIE_TYPE_RSS_091_NETSCAPE RSS 0.91 (Netscape).
+         * @see SIMPLEPIE_TYPE_RSS_091_USERLAND RSS 0.91 (Userland).
+         * @see SIMPLEPIE_TYPE_RSS_091 RSS 0.91.
+         * @see SIMPLEPIE_TYPE_RSS_092 RSS 0.92.
+         * @see SIMPLEPIE_TYPE_RSS_093 RSS 0.93.
+         * @see SIMPLEPIE_TYPE_RSS_094 RSS 0.94.
+         * @see SIMPLEPIE_TYPE_RSS_10 RSS 1.0.
+         * @see SIMPLEPIE_TYPE_RSS_20 RSS 2.0.x.
+         * @see SIMPLEPIE_TYPE_RSS_RDF RDF-based RSS.
+         * @see SIMPLEPIE_TYPE_RSS_SYNDICATION Non-RDF-based RSS (truly intended as syndication format).
+         * @see SIMPLEPIE_TYPE_RSS_ALL Any version of RSS.
+         * @see SIMPLEPIE_TYPE_ATOM_03 Atom 0.3.
+         * @see SIMPLEPIE_TYPE_ATOM_10 Atom 1.0.
+         * @see SIMPLEPIE_TYPE_ATOM_ALL Any version of Atom.
+         * @see SIMPLEPIE_TYPE_ALL Any known/supported feed type.
+         * @return int SIMPLEPIE_TYPE_* constant
+         */
+        public function get_type()
+        {
+                if (!isset($this->data['type']))
+                {
+                        $this->data['type'] = SIMPLEPIE_TYPE_ALL;
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed']))
+                        {
+                                $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_10;
+                        }
+                        elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed']))
+                        {
+                                $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_03;
+                        }
+                        elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF']))
+                        {
+                                if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['channel'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['image'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['textinput']))
+                                {
+                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_10;
+                                }
+                                if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['channel'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['image'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item'])
+                                || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['textinput']))
+                                {
+                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_090;
+                                }
+                        }
+                        elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss']))
+                        {
+                                $this->data['type'] &= SIMPLEPIE_TYPE_RSS_ALL;
+                                if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version']))
+                                {
+                                        switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version']))
+                                        {
+                                                case '0.91':
+                                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091;
+                                                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data']))
+                                                        {
+                                                                switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data']))
+                                                                {
+                                                                        case '0':
+                                                                                $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_NETSCAPE;
+                                                                                break;
+
+                                                                        case '24':
+                                                                                $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_USERLAND;
+                                                                                break;
+                                                                }
+                                                        }
+                                                        break;
+
+                                                case '0.92':
+                                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_092;
+                                                        break;
+
+                                                case '0.93':
+                                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_093;
+                                                        break;
+
+                                                case '0.94':
+                                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_094;
+                                                        break;
+
+                                                case '2.0':
+                                                        $this->data['type'] &= SIMPLEPIE_TYPE_RSS_20;
+                                                        break;
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                $this->data['type'] = SIMPLEPIE_TYPE_NONE;
+                        }
+                }
+                return $this->data['type'];
+        }
+
+        /**
+         * Get the URL for the feed
+         *
+         * May or may not be different from the URL passed to {@see set_feed_url()},
+         * depending on whether auto-discovery was used.
+         *
+         * @since Preview Release (previously called `get_feed_url()` since SimplePie 0.8.)
+         * @todo If we have a perm redirect we should return the new URL
+         * @todo When we make the above change, let's support <itunes:new-feed-url> as well
+         * @todo Also, |atom:link|@rel=self
+         * @return string|null
+         */
+        public function subscribe_url()
+        {
+                if ($this->feed_url !== null)
+                {
+                        return $this->sanitize($this->feed_url, SIMPLEPIE_CONSTRUCT_IRI);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get data for an feed-level element
+         *
+         * This method allows you to get access to ANY element/attribute that is a
+         * sub-element of the opening feed tag.
+         *
+         * The return value is an indexed array of elements matching the given
+         * namespace and tag name. Each element has `attribs`, `data` and `child`
+         * subkeys. For `attribs` and `child`, these contain namespace subkeys.
+         * `attribs` then has one level of associative name => value data (where
+         * `value` is a string) after the namespace. `child` has tag-indexed keys
+         * after the namespace, each member of which is an indexed array matching
+         * this same format.
+         *
+         * For example:
+         * <pre>
+         * // This is probably a bad example because we already support
+         * // <media:content> natively, but it shows you how to parse through
+         * // the nodes.
+         * $group = $item->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group');
+         * $content = $group[0]['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'];
+         * $file = $content[0]['attribs']['']['url'];
+         * echo $file;
+         * </pre>
+         *
+         * @since 1.0
+         * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
+         * @param string $namespace The URL of the XML namespace of the elements you're trying to access
+         * @param string $tag Tag name
+         * @return array
+         */
+        public function get_feed_tags($namespace, $tag)
+        {
+                $type = $this->get_type();
+                if ($type & SIMPLEPIE_TYPE_ATOM_10)
+                {
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag]))
+                        {
+                                return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag];
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_ATOM_03)
+                {
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag]))
+                        {
+                                return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag];
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_RDF)
+                {
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag]))
+                        {
+                                return $this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag];
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION)
+                {
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag]))
+                        {
+                                return $this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag];
+                        }
+                }
+                return null;
+        }
+
+        /**
+         * Get data for an channel-level element
+         *
+         * This method allows you to get access to ANY element/attribute in the
+         * channel/header section of the feed.
+         *
+         * See {@see SimplePie::get_feed_tags()} for a description of the return value
+         *
+         * @since 1.0
+         * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
+         * @param string $namespace The URL of the XML namespace of the elements you're trying to access
+         * @param string $tag Tag name
+         * @return array
+         */
+        public function get_channel_tags($namespace, $tag)
+        {
+                $type = $this->get_type();
+                if ($type & SIMPLEPIE_TYPE_ATOM_ALL)
+                {
+                        if ($return = $this->get_feed_tags($namespace, $tag))
+                        {
+                                return $return;
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_10)
+                {
+                        if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'channel'))
+                        {
+                                if (isset($channel[0]['child'][$namespace][$tag]))
+                                {
+                                        return $channel[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_090)
+                {
+                        if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'channel'))
+                        {
+                                if (isset($channel[0]['child'][$namespace][$tag]))
+                                {
+                                        return $channel[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION)
+                {
+                        if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'channel'))
+                        {
+                                if (isset($channel[0]['child'][$namespace][$tag]))
+                                {
+                                        return $channel[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                return null;
+        }
+
+        /**
+         * Get data for an channel-level element
+         *
+         * This method allows you to get access to ANY element/attribute in the
+         * image/logo section of the feed.
+         *
+         * See {@see SimplePie::get_feed_tags()} for a description of the return value
+         *
+         * @since 1.0
+         * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
+         * @param string $namespace The URL of the XML namespace of the elements you're trying to access
+         * @param string $tag Tag name
+         * @return array
+         */
+        public function get_image_tags($namespace, $tag)
+        {
+                $type = $this->get_type();
+                if ($type & SIMPLEPIE_TYPE_RSS_10)
+                {
+                        if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'image'))
+                        {
+                                if (isset($image[0]['child'][$namespace][$tag]))
+                                {
+                                        return $image[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_090)
+                {
+                        if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'image'))
+                        {
+                                if (isset($image[0]['child'][$namespace][$tag]))
+                                {
+                                        return $image[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION)
+                {
+                        if ($image = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'image'))
+                        {
+                                if (isset($image[0]['child'][$namespace][$tag]))
+                                {
+                                        return $image[0]['child'][$namespace][$tag];
+                                }
+                        }
+                }
+                return null;
+        }
+
+        /**
+         * Get the base URL value from the feed
+         *
+         * Uses `<xml:base>` if available, otherwise uses the first link in the
+         * feed, or failing that, the URL of the feed itself.
+         *
+         * @see get_link
+         * @see subscribe_url
+         *
+         * @param array $element
+         * @return string
+         */
+        public function get_base($element = array())
+        {
+                if (!($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION) && !empty($element['xml_base_explicit']) && isset($element['xml_base']))
+                {
+                        return $element['xml_base'];
+                }
+                elseif ($this->get_link() !== null)
+                {
+                        return $this->get_link();
+                }
+                else
+                {
+                        return $this->subscribe_url();
+                }
+        }
+
+        /**
+         * Sanitize feed data
+         *
+         * @access private
+         * @see SimplePie_Sanitize::sanitize()
+         * @param string $data Data to sanitize
+         * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants
+         * @param string $base Base URL to resolve URLs against
+         * @return string Sanitized data
+         */
+        public function sanitize($data, $type, $base = '')
+        {
+                return $this->sanitize->sanitize($data, $type, $base);
+        }
+
+        /**
+         * Get the title of the feed
+         *
+         * Uses `<atom:title>`, `<title>` or `<dc:title>`
+         *
+         * @since 1.0 (previously called `get_feed_title` since 0.8)
+         * @return string|null
+         */
+        public function get_title()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a category for the feed
+         *
+         * @since Unknown
+         * @param int $key The category that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Category|null
+         */
+        public function get_category($key = 0)
+        {
+                $categories = $this->get_categories();
+                if (isset($categories[$key]))
+                {
+                        return $categories[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all categories for the feed
+         *
+         * Uses `<atom:category>`, `<category>` or `<dc:subject>`
+         *
+         * @since Unknown
+         * @return array|null List of {@see SimplePie_Category} objects
+         */
+        public function get_categories()
+        {
+                $categories = array();
+
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category)
+                {
+                        $term = null;
+                        $scheme = null;
+                        $label = null;
+                        if (isset($category['attribs']['']['term']))
+                        {
+                                $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['scheme']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['label']))
+                        {
+                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category)
+                {
+                        // This is really the label, but keep this as the term also for BC.
+                        // Label will also work on retrieving because that falls back to term.
+                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        if (isset($category['attribs']['']['domain']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        else
+                        {
+                                $scheme = null;
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, null));
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($categories))
+                {
+                        return array_unique($categories);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get an author for the feed
+         *
+         * @since 1.1
+         * @param int $key The author that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Author|null
+         */
+        public function get_author($key = 0)
+        {
+                $authors = $this->get_authors();
+                if (isset($authors[$key]))
+                {
+                        return $authors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all authors for the feed
+         *
+         * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>`
+         *
+         * @since 1.1
+         * @return array|null List of {@see SimplePie_Author} objects
+         */
+        public function get_authors()
+        {
+                $authors = array();
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                if ($author = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($authors))
+                {
+                        return array_unique($authors);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a contributor for the feed
+         *
+         * @since 1.1
+         * @param int $key The contrbutor that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Author|null
+         */
+        public function get_contributor($key = 0)
+        {
+                $contributors = $this->get_contributors();
+                if (isset($contributors[$key]))
+                {
+                        return $contributors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all contributors for the feed
+         *
+         * Uses `<atom:contributor>`
+         *
+         * @since 1.1
+         * @return array|null List of {@see SimplePie_Author} objects
+         */
+        public function get_contributors()
+        {
+                $contributors = array();
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+
+                if (!empty($contributors))
+                {
+                        return array_unique($contributors);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single link for the feed
+         *
+         * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8)
+         * @param int $key The link that you want to return.  Remember that arrays begin with 0, not 1
+         * @param string $rel The relationship of the link to return
+         * @return string|null Link URL
+         */
+        public function get_link($key = 0, $rel = 'alternate')
+        {
+                $links = $this->get_links($rel);
+                if (isset($links[$key]))
+                {
+                        return $links[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the permalink for the item
+         *
+         * Returns the first link available with a relationship of "alternate".
+         * Identical to {@see get_link()} with key 0
+         *
+         * @see get_link
+         * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8)
+         * @internal Added for parity between the parent-level and the item/entry-level.
+         * @return string|null Link URL
+         */
+        public function get_permalink()
+        {
+                return $this->get_link(0);
+        }
+
+        /**
+         * Get all links for the feed
+         *
+         * Uses `<atom:link>` or `<link>`
+         *
+         * @since Beta 2
+         * @param string $rel The relationship of links to return
+         * @return array|null Links found for the feed (strings)
+         */
+        public function get_links($rel = 'alternate')
+        {
+                if (!isset($this->data['links']))
+                {
+                        $this->data['links'] = array();
+                        if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link'))
+                        {
+                                foreach ($links as $link)
+                                {
+                                        if (isset($link['attribs']['']['href']))
+                                        {
+                                                $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                                $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+                                        }
+                                }
+                        }
+                        if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link'))
+                        {
+                                foreach ($links as $link)
+                                {
+                                        if (isset($link['attribs']['']['href']))
+                                        {
+                                                $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                                $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+
+                                        }
+                                }
+                        }
+                        if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+
+                        $keys = array_keys($this->data['links']);
+                        foreach ($keys as $key)
+                        {
+                                if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key)))
+                                {
+                                        if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]))
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]);
+                                                $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key];
+                                        }
+                                        else
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key];
+                                        }
+                                }
+                                elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY)
+                                {
+                                        $this->data['links'][substr($key, 41)] =& $this->data['links'][$key];
+                                }
+                                $this->data['links'][$key] = array_unique($this->data['links'][$key]);
+                        }
+                }
+
+                if (isset($this->data['links'][$rel]))
+                {
+                        return $this->data['links'][$rel];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_all_discovered_feeds()
+        {
+                return $this->all_discovered_feeds;
+        }
+
+        /**
+         * Get the content for the item
+         *
+         * Uses `<atom:subtitle>`, `<atom:tagline>`, `<description>`,
+         * `<dc:description>`, `<itunes:summary>` or `<itunes:subtitle>`
+         *
+         * @since 1.0 (previously called `get_feed_description()` since 0.8)
+         * @return string|null
+         */
+        public function get_description()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'subtitle'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'tagline'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the copyright info for the feed
+         *
+         * Uses `<atom:rights>`, `<atom:copyright>` or `<dc:rights>`
+         *
+         * @since 1.0 (previously called `get_feed_copyright()` since 0.8)
+         * @return string|null
+         */
+        public function get_copyright()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'copyright'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'copyright'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the language for the feed
+         *
+         * Uses `<language>`, `<dc:language>`, or @xml_lang
+         *
+         * @since 1.0 (previously called `get_feed_language()` since 0.8)
+         * @return string|null
+         */
+        public function get_language()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang']))
+                {
+                        return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang']))
+                {
+                        return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang']))
+                {
+                        return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (isset($this->data['headers']['content-language']))
+                {
+                        return $this->sanitize($this->data['headers']['content-language'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the latitude coordinates for the item
+         *
+         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
+         *
+         * Uses `<geo:lat>` or `<georss:point>`
+         *
+         * @since 1.0
+         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
+         * @link http://www.georss.org/ GeoRSS
+         * @return string|null
+         */
+        public function get_latitude()
+        {
+
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[1];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the longitude coordinates for the feed
+         *
+         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
+         *
+         * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>`
+         *
+         * @since 1.0
+         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
+         * @link http://www.georss.org/ GeoRSS
+         * @return string|null
+         */
+        public function get_longitude()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[2];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the feed logo's title
+         *
+         * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" title.
+         *
+         * Uses `<image><title>` or `<image><dc:title>`
+         *
+         * @return string|null
+         */
+        public function get_image_title()
+        {
+                if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the feed logo's URL
+         *
+         * RSS 0.9.0, 2.0, Atom 1.0, and feeds with iTunes RSS tags are allowed to
+         * have a "feed logo" URL. This points directly to the image itself.
+         *
+         * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`,
+         * `<image><title>` or `<image><dc:title>`
+         *
+         * @return string|null
+         */
+        public function get_image_url()
+        {
+                if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'image'))
+                {
+                        return $this->sanitize($return[0]['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI);
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'logo'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'icon'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'url'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'url'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+
+        /**
+         * Get the feed logo's link
+         *
+         * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" link. This
+         * points to a human-readable page that the image should link to.
+         *
+         * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`,
+         * `<image><title>` or `<image><dc:title>`
+         *
+         * @return string|null
+         */
+        public function get_image_link()
+        {
+                if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the feed logo's link
+         *
+         * RSS 2.0 feeds are allowed to have a "feed logo" width.
+         *
+         * Uses `<image><width>` or defaults to 88.0 if no width is specified and
+         * the feed is an RSS 2.0 feed.
+         *
+         * @return int|float|null
+         */
+        public function get_image_width()
+        {
+                if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'width'))
+                {
+                        return round($return[0]['data']);
+                }
+                elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url'))
+                {
+                        return 88.0;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the feed logo's height
+         *
+         * RSS 2.0 feeds are allowed to have a "feed logo" height.
+         *
+         * Uses `<image><height>` or defaults to 31.0 if no height is specified and
+         * the feed is an RSS 2.0 feed.
+         *
+         * @return int|float|null
+         */
+        public function get_image_height()
+        {
+                if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'height'))
+                {
+                        return round($return[0]['data']);
+                }
+                elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url'))
+                {
+                        return 31.0;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the number of items in the feed
+         *
+         * This is well-suited for {@link http://php.net/for for()} loops with
+         * {@see get_item()}
+         *
+         * @param int $max Maximum value to return. 0 for no limit
+         * @return int Number of items in the feed
+         */
+        public function get_item_quantity($max = 0)
+        {
+                $max = (int) $max;
+                $qty = count($this->get_items());
+                if ($max === 0)
+                {
+                        return $qty;
+                }
+                else
+                {
+                        return ($qty > $max) ? $max : $qty;
+                }
+        }
+
+        /**
+         * Get a single item from the feed
+         *
+         * This is better suited for {@link http://php.net/for for()} loops, whereas
+         * {@see get_items()} is better suited for
+         * {@link http://php.net/foreach foreach()} loops.
+         *
+         * @see get_item_quantity()
+         * @since Beta 2
+         * @param int $key The item that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Item|null
+         */
+        public function get_item($key = 0)
+        {
+                $items = $this->get_items();
+                if (isset($items[$key]))
+                {
+                        return $items[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all items from the feed
+         *
+         * This is better suited for {@link http://php.net/for for()} loops, whereas
+         * {@see get_items()} is better suited for
+         * {@link http://php.net/foreach foreach()} loops.
+         *
+         * @see get_item_quantity
+         * @since Beta 2
+         * @param int $start Index to start at
+         * @param int $end Number of items to return. 0 for all items after `$start`
+         * @return array|null List of {@see SimplePie_Item} objects
+         */
+        public function get_items($start = 0, $end = 0)
+        {
+                if (!isset($this->data['items']))
+                {
+                        if (!empty($this->multifeed_objects))
+                        {
+                                $this->data['items'] = SimplePie::merge_items($this->multifeed_objects, $start, $end, $this->item_limit);
+                        }
+                        else
+                        {
+                                $this->data['items'] = array();
+                                if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'entry'))
+                                {
+                                        $keys = array_keys($items);
+                                        foreach ($keys as $key)
+                                        {
+                                                $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key]));
+                                        }
+                                }
+                                if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'entry'))
+                                {
+                                        $keys = array_keys($items);
+                                        foreach ($keys as $key)
+                                        {
+                                                $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key]));
+                                        }
+                                }
+                                if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'item'))
+                                {
+                                        $keys = array_keys($items);
+                                        foreach ($keys as $key)
+                                        {
+                                                $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key]));
+                                        }
+                                }
+                                if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'item'))
+                                {
+                                        $keys = array_keys($items);
+                                        foreach ($keys as $key)
+                                        {
+                                                $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key]));
+                                        }
+                                }
+                                if ($items = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'item'))
+                                {
+                                        $keys = array_keys($items);
+                                        foreach ($keys as $key)
+                                        {
+                                                $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key]));
+                                        }
+                                }
+                        }
+                }
+
+                if (!empty($this->data['items']))
+                {
+                        // If we want to order it by date, check if all items have a date, and then sort it
+                        if ($this->order_by_date && empty($this->multifeed_objects))
+                        {
+                                if (!isset($this->data['ordered_items']))
+                                {
+                                        $do_sort = true;
+                                        foreach ($this->data['items'] as $item)
+                                        {
+                                                if (!$item->get_date('U'))
+                                                {
+                                                        $do_sort = false;
+                                                        break;
+                                                }
+                                        }
+                                        $item = null;
+                                        $this->data['ordered_items'] = $this->data['items'];
+                                        if ($do_sort)
+                                        {
+                                                usort($this->data['ordered_items'], array(get_class($this), 'sort_items'));
+                                        }
+                                }
+                                $items = $this->data['ordered_items'];
+                        }
+                        else
+                        {
+                                $items = $this->data['items'];
+                        }
+
+                        // Slice the data as desired
+                        if ($end === 0)
+                        {
+                                return array_slice($items, $start);
+                        }
+                        else
+                        {
+                                return array_slice($items, $start, $end);
+                        }
+                }
+                else
+                {
+                        return array();
+                }
+        }
+
+        /**
+         * Set the favicon handler
+         *
+         * @deprecated Use your own favicon handling instead
+         */
+        public function set_favicon_handler($page = false, $qs = 'i')
+        {
+                $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING;
+                trigger_error('Favicon handling has been removed, please use your own handling', $level);
+                return false;
+        }
+
+        /**
+         * Get the favicon for the current feed
+         *
+         * @deprecated Use your own favicon handling instead
+         */
+        public function get_favicon()
+        {
+                $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING;
+                trigger_error('Favicon handling has been removed, please use your own handling', $level);
+
+                if (($url = $this->get_link()) !== null)
+                {
+                        return 'http://g.etfv.co/' . urlencode($url);
+                }
+
+                return false;
+        }
+
+        /**
+         * Magic method handler
+         *
+         * @param string $method Method name
+         * @param array $args Arguments to the method
+         * @return mixed
+         */
+        public function __call($method, $args)
+        {
+                if (strpos($method, 'subscribe_') === 0)
+                {
+                        $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING;
+                        trigger_error('subscribe_*() has been deprecated, implement the callback yourself', $level);
+                        return '';
+                }
+                if ($method === 'enable_xml_dump')
+                {
+                        $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING;
+                        trigger_error('enable_xml_dump() has been deprecated, use get_raw_data() instead', $level);
+                        return false;
+                }
+
+                $class = get_class($this);
+                $trace = debug_backtrace();
+                $file = $trace[0]['file'];
+                $line = $trace[0]['line'];
+                trigger_error("Call to undefined method $class::$method() in $file on line $line", E_USER_ERROR);
+        }
+
+        /**
+         * Sorting callback for items
+         *
+         * @access private
+         * @param SimplePie $a
+         * @param SimplePie $b
+         * @return boolean
+         */
+        public static function sort_items($a, $b)
+        {
+                return $a->get_date('U') <= $b->get_date('U');
+        }
+
+        /**
+         * Merge items from several feeds into one
+         *
+         * If you're merging multiple feeds together, they need to all have dates
+         * for the items or else SimplePie will refuse to sort them.
+         *
+         * @link http://simplepie.org/wiki/tutorial/sort_multiple_feeds_by_time_and_date#if_feeds_require_separate_per-feed_settings
+         * @param array $urls List of SimplePie feed objects to merge
+         * @param int $start Starting item
+         * @param int $end Number of items to return
+         * @param int $limit Maximum number of items per feed
+         * @return array
+         */
+        public static function merge_items($urls, $start = 0, $end = 0, $limit = 0)
+        {
+                if (is_array($urls) && sizeof($urls) > 0)
+                {
+                        $items = array();
+                        foreach ($urls as $arg)
+                        {
+                                if ($arg instanceof SimplePie)
+                                {
+                                        $items = array_merge($items, $arg->get_items(0, $limit));
+                                }
+                                else
+                                {
+                                        trigger_error('Arguments must be SimplePie objects', E_USER_WARNING);
+                                }
+                        }
+
+                        $do_sort = true;
+                        foreach ($items as $item)
+                        {
+                                if (!$item->get_date('U'))
+                                {
+                                        $do_sort = false;
+                                        break;
+                                }
+                        }
+                        $item = null;
+                        if ($do_sort)
+                        {
+                                usort($items, array(get_class($urls[0]), 'sort_items'));
+                        }
+
+                        if ($end === 0)
+                        {
+                                return array_slice($items, $start);
+                        }
+                        else
+                        {
+                                return array_slice($items, $start, $end);
+                        }
+                }
+                else
+                {
+                        trigger_error('Cannot merge zero SimplePie objects', E_USER_WARNING);
+                        return array();
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Author.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Author.php
new file mode 100644
index 00000000..bbf3812f
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Author.php
@@ -0,0 +1,157 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Manages all author-related data
+ *
+ * Used by {@see SimplePie_Item::get_author()} and {@see SimplePie::get_authors()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_author_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Author
+{
+        /**
+         * Author's name
+         *
+         * @var string
+         * @see get_name()
+         */
+        var $name;
+
+        /**
+         * Author's link
+         *
+         * @var string
+         * @see get_link()
+         */
+        var $link;
+
+        /**
+         * Author's email address
+         *
+         * @var string
+         * @see get_email()
+         */
+        var $email;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * @param string $name
+         * @param string $link
+         * @param string $email
+         */
+        public function __construct($name = null, $link = null, $email = null)
+        {
+                $this->name = $name;
+                $this->link = $link;
+                $this->email = $email;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Author's name
+         *
+         * @return string|null
+         */
+        public function get_name()
+        {
+                if ($this->name !== null)
+                {
+                        return $this->name;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Author's link
+         *
+         * @return string|null
+         */
+        public function get_link()
+        {
+                if ($this->link !== null)
+                {
+                        return $this->link;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Author's email address
+         *
+         * @return string|null
+         */
+        public function get_email()
+        {
+                if ($this->email !== null)
+                {
+                        return $this->email;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache.php
new file mode 100644
index 00000000..75586d74
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache.php
@@ -0,0 +1,133 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Used to create cache objects
+ *
+ * This class can be overloaded with {@see SimplePie::set_cache_class()},
+ * although the preferred way is to create your own handler
+ * via {@see register()}
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ */
+class SimplePie_Cache
+{
+        /**
+         * Cache handler classes
+         *
+         * These receive 3 parameters to their constructor, as documented in
+         * {@see register()}
+         * @var array
+         */
+        protected static $handlers = array(
+                'mysql' => 'SimplePie_Cache_MySQL',
+                'memcache' => 'SimplePie_Cache_Memcache',
+        );
+
+        /**
+         * Don't call the constructor. Please.
+         */
+        private function __construct() { }
+
+        /**
+         * Create a new SimplePie_Cache object
+         *
+         * @param string $location URL location (scheme is used to determine handler)
+         * @param string $filename Unique identifier for cache object
+         * @param string $extension 'spi' or 'spc'
+         * @return SimplePie_Cache_Base Type of object depends on scheme of `$location`
+         */
+        public static function get_handler($location, $filename, $extension)
+        {
+                $type = explode(':', $location, 2);
+                $type = $type[0];
+                if (!empty(self::$handlers[$type]))
+                {
+                        $class = self::$handlers[$type];
+                        return new $class($location, $filename, $extension);
+                }
+
+                return new SimplePie_Cache_File($location, $filename, $extension);
+        }
+
+        /**
+         * Create a new SimplePie_Cache object
+         *
+         * @deprecated Use {@see get_handler} instead
+         */
+        public function create($location, $filename, $extension)
+        {
+                trigger_error('Cache::create() has been replaced with Cache::get_handler(). Switch to the registry system to use this.', E_USER_DEPRECATED);
+                return self::get_handler($location, $filename, $extension);
+        }
+
+        /**
+         * Register a handler
+         *
+         * @param string $type DSN type to register for
+         * @param string $class Name of handler class. Must implement SimplePie_Cache_Base
+         */
+        public static function register($type, $class)
+        {
+                self::$handlers[$type] = $class;
+        }
+
+        /**
+         * Parse a URL into an array
+         *
+         * @param string $url
+         * @return array
+         */
+        public static function parse_URL($url)
+        {
+                $params = parse_url($url);
+                $params['extras'] = array();
+                if (isset($params['query']))
+                {
+                        parse_str($params['query'], $params['extras']);
+                }
+                return $params;
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Base.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Base.php
new file mode 100644
index 00000000..937e3463
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Base.php
@@ -0,0 +1,114 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Base for cache objects
+ *
+ * Classes to be used with {@see SimplePie_Cache::register()} are expected
+ * to implement this interface.
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ */
+interface SimplePie_Cache_Base
+{
+        /**
+         * Feed cache type
+         *
+         * @var string
+         */
+        const TYPE_FEED = 'spc';
+
+        /**
+         * Image cache type
+         *
+         * @var string
+         */
+        const TYPE_IMAGE = 'spi';
+
+        /**
+         * Create a new cache object
+         *
+         * @param string $location Location string (from SimplePie::$cache_location)
+         * @param string $name Unique ID for the cache
+         * @param string $type Either TYPE_FEED for SimplePie data, or TYPE_IMAGE for image data
+         */
+        public function __construct($location, $name, $type);
+
+        /**
+         * Save data to the cache
+         *
+         * @param array|SimplePie $data Data to store in the cache. If passed a SimplePie object, only cache the $data property
+         * @return bool Successfulness
+         */
+        public function save($data);
+
+        /**
+         * Retrieve the data saved to the cache
+         *
+         * @return array Data for SimplePie::$data
+         */
+        public function load();
+
+        /**
+         * Retrieve the last modified time for the cache
+         *
+         * @return int Timestamp
+         */
+        public function mtime();
+
+        /**
+         * Set the last modified time to the current time
+         *
+         * @return bool Success status
+         */
+        public function touch();
+
+        /**
+         * Remove the cache
+         *
+         * @return bool Success status
+         */
+        public function unlink();
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/DB.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/DB.php
new file mode 100644
index 00000000..ac509ae0
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/DB.php
@@ -0,0 +1,137 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Base class for database-based caches
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ */
+abstract class SimplePie_Cache_DB implements SimplePie_Cache_Base
+{
+        /**
+         * Helper for database conversion
+         *
+         * Converts a given {@see SimplePie} object into data to be stored
+         *
+         * @param SimplePie $data
+         * @return array First item is the serialized data for storage, second item is the unique ID for this item
+         */
+        protected static function prepare_simplepie_object_for_cache($data)
+        {
+                $items = $data->get_items();
+                $items_by_id = array();
+
+                if (!empty($items))
+                {
+                        foreach ($items as $item)
+                        {
+                                $items_by_id[$item->get_id()] = $item;
+                        }
+
+                        if (count($items_by_id) !== count($items))
+                        {
+                                $items_by_id = array();
+                                foreach ($items as $item)
+                                {
+                                        $items_by_id[$item->get_id(true)] = $item;
+                                }
+                        }
+
+                        if (isset($data->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]))
+                        {
+                                $channel =& $data->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0];
+                        }
+                        elseif (isset($data->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]))
+                        {
+                                $channel =& $data->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0];
+                        }
+                        elseif (isset($data->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]))
+                        {
+                                $channel =& $data->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0];
+                        }
+                        elseif (isset($data->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['channel'][0]))
+                        {
+                                $channel =& $data->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['channel'][0];
+                        }
+                        else
+                        {
+                                $channel = null;
+                        }
+
+                        if ($channel !== null)
+                        {
+                                if (isset($channel['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['entry']))
+                                {
+                                        unset($channel['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['entry']);
+                                }
+                                if (isset($channel['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['entry']))
+                                {
+                                        unset($channel['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['entry']);
+                                }
+                                if (isset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item']))
+                                {
+                                        unset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item']);
+                                }
+                                if (isset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item']))
+                                {
+                                        unset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item']);
+                                }
+                                if (isset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_20]['item']))
+                                {
+                                        unset($channel['child'][SIMPLEPIE_NAMESPACE_RSS_20]['item']);
+                                }
+                        }
+                        if (isset($data->data['items']))
+                        {
+                                unset($data->data['items']);
+                        }
+                        if (isset($data->data['ordered_items']))
+                        {
+                                unset($data->data['ordered_items']);
+                        }
+                }
+                return array(serialize($data->data), $items_by_id);
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/File.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/File.php
new file mode 100644
index 00000000..5797b3ae
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/File.php
@@ -0,0 +1,173 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Caches data to the filesystem
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ */
+class SimplePie_Cache_File implements SimplePie_Cache_Base
+{
+        /**
+         * Location string
+         *
+         * @see SimplePie::$cache_location
+         * @var string
+         */
+        protected $location;
+
+        /**
+         * Filename
+         *
+         * @var string
+         */
+        protected $filename;
+
+        /**
+         * File extension
+         *
+         * @var string
+         */
+        protected $extension;
+
+        /**
+         * File path
+         *
+         * @var string
+         */
+        protected $name;
+
+        /**
+         * Create a new cache object
+         *
+         * @param string $location Location string (from SimplePie::$cache_location)
+         * @param string $name Unique ID for the cache
+         * @param string $type Either TYPE_FEED for SimplePie data, or TYPE_IMAGE for image data
+         */
+        public function __construct($location, $name, $type)
+        {
+                $this->location = $location;
+                $this->filename = $name;
+                $this->extension = $type;
+                $this->name = "$this->location/$this->filename.$this->extension";
+        }
+
+        /**
+         * Save data to the cache
+         *
+         * @param array|SimplePie $data Data to store in the cache. If passed a SimplePie object, only cache the $data property
+         * @return bool Successfulness
+         */
+        public function save($data)
+        {
+                if (file_exists($this->name) && is_writeable($this->name) || file_exists($this->location) && is_writeable($this->location))
+                {
+                        if ($data instanceof SimplePie)
+                        {
+                                $data = $data->data;
+                        }
+
+                        $data = serialize($data);
+                        return (bool) file_put_contents($this->name, $data);
+                }
+                return false;
+        }
+
+        /**
+         * Retrieve the data saved to the cache
+         *
+         * @return array Data for SimplePie::$data
+         */
+        public function load()
+        {
+                if (file_exists($this->name) && is_readable($this->name))
+                {
+                        return unserialize(file_get_contents($this->name));
+                }
+                return false;
+        }
+
+        /**
+         * Retrieve the last modified time for the cache
+         *
+         * @return int Timestamp
+         */
+        public function mtime()
+        {
+                if (file_exists($this->name))
+                {
+                        return filemtime($this->name);
+                }
+                return false;
+        }
+
+        /**
+         * Set the last modified time to the current time
+         *
+         * @return bool Success status
+         */
+        public function touch()
+        {
+                if (file_exists($this->name))
+                {
+                        return touch($this->name);
+                }
+                return false;
+        }
+
+        /**
+         * Remove the cache
+         *
+         * @return bool Success status
+         */
+        public function unlink()
+        {
+                if (file_exists($this->name))
+                {
+                        return unlink($this->name);
+                }
+                return false;
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Memcache.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Memcache.php
new file mode 100644
index 00000000..fd447806
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/Memcache.php
@@ -0,0 +1,183 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Caches data to memcache
+ *
+ * Registered for URLs with the "memcache" protocol
+ *
+ * For example, `memcache://localhost:11211/?timeout=3600&prefix=sp_` will
+ * connect to memcache on `localhost` on port 11211. All tables will be
+ * prefixed with `sp_` and data will expire after 3600 seconds
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ * @uses Memcache
+ */
+class SimplePie_Cache_Memcache implements SimplePie_Cache_Base
+{
+        /**
+         * Memcache instance
+         *
+         * @var Memcache
+         */
+        protected $cache;
+
+        /**
+         * Options
+         *
+         * @var array
+         */
+        protected $options;
+
+        /**
+         * Cache name
+         *
+         * @var string
+         */
+        protected $name;
+
+        /**
+         * Create a new cache object
+         *
+         * @param string $location Location string (from SimplePie::$cache_location)
+         * @param string $name Unique ID for the cache
+         * @param string $type Either TYPE_FEED for SimplePie data, or TYPE_IMAGE for image data
+         */
+        public function __construct($location, $name, $type)
+        {
+                $this->options = array(
+                        'host' => '127.0.0.1',
+                        'port' => 11211,
+                        'extras' => array(
+                                'timeout' => 3600, // one hour
+                                'prefix' => 'simplepie_',
+                        ),
+                );
+                $parsed = SimplePie_Cache::parse_URL($location);
+                $this->options['host'] = empty($parsed['host']) ? $this->options['host'] : $parsed['host'];
+                $this->options['port'] = empty($parsed['port']) ? $this->options['port'] : $parsed['port'];
+                $this->options['extras'] = array_merge($this->options['extras'], $parsed['extras']);
+                $this->name = $this->options['extras']['prefix'] . md5("$name:$type");
+
+                $this->cache = new Memcache();
+                $this->cache->addServer($this->options['host'], (int) $this->options['port']);
+        }
+
+        /**
+         * Save data to the cache
+         *
+         * @param array|SimplePie $data Data to store in the cache. If passed a SimplePie object, only cache the $data property
+         * @return bool Successfulness
+         */
+        public function save($data)
+        {
+                if ($data instanceof SimplePie)
+                {
+                        $data = $data->data;
+                }
+                return $this->cache->set($this->name, serialize($data), MEMCACHE_COMPRESSED, (int) $this->options['extras']['timeout']);
+        }
+
+        /**
+         * Retrieve the data saved to the cache
+         *
+         * @return array Data for SimplePie::$data
+         */
+        public function load()
+        {
+                $data = $this->cache->get($this->name);
+
+                if ($data !== false)
+                {
+                        return unserialize($data);
+                }
+                return false;
+        }
+
+        /**
+         * Retrieve the last modified time for the cache
+         *
+         * @return int Timestamp
+         */
+        public function mtime()
+        {
+                $data = $this->cache->get($this->name);
+
+                if ($data !== false)
+                {
+                        // essentially ignore the mtime because Memcache expires on it's own
+                        return time();
+                }
+
+                return false;
+        }
+
+        /**
+         * Set the last modified time to the current time
+         *
+         * @return bool Success status
+         */
+        public function touch()
+        {
+                $data = $this->cache->get($this->name);
+
+                if ($data !== false)
+                {
+                        return $this->cache->set($this->name, $data, MEMCACHE_COMPRESSED, (int) $this->duration);
+                }
+
+                return false;
+        }
+
+        /**
+         * Remove the cache
+         *
+         * @return bool Success status
+         */
+        public function unlink()
+        {
+                return $this->cache->delete($this->name, 0);
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/MySQL.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/MySQL.php
new file mode 100644
index 00000000..d53ebc11
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Cache/MySQL.php
@@ -0,0 +1,438 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Caches data to a MySQL database
+ *
+ * Registered for URLs with the "mysql" protocol
+ *
+ * For example, `mysql://root:password@localhost:3306/mydb?prefix=sp_` will
+ * connect to the `mydb` database on `localhost` on port 3306, with the user
+ * `root` and the password `password`. All tables will be prefixed with `sp_`
+ *
+ * @package SimplePie
+ * @subpackage Caching
+ */
+class SimplePie_Cache_MySQL extends SimplePie_Cache_DB
+{
+        /**
+         * PDO instance
+         *
+         * @var PDO
+         */
+        protected $mysql;
+
+        /**
+         * Options
+         *
+         * @var array
+         */
+        protected $options;
+
+        /**
+         * Cache ID
+         *
+         * @var string
+         */
+        protected $id;
+
+        /**
+         * Create a new cache object
+         *
+         * @param string $location Location string (from SimplePie::$cache_location)
+         * @param string $name Unique ID for the cache
+         * @param string $type Either TYPE_FEED for SimplePie data, or TYPE_IMAGE for image data
+         */
+        public function __construct($location, $name, $type)
+        {
+                $this->options = array(
+                        'user' => null,
+                        'pass' => null,
+                        'host' => '127.0.0.1',
+                        'port' => '3306',
+                        'path' => '',
+                        'extras' => array(
+                                'prefix' => '',
+                        ),
+                );
+                $this->options = array_merge_recursive($this->options, SimplePie_Cache::parse_URL($location));
+
+                // Path is prefixed with a "/"
+                $this->options['dbname'] = substr($this->options['path'], 1);
+
+                try
+                {
+                        $this->mysql = new PDO("mysql:dbname={$this->options['dbname']};host={$this->options['host']};port={$this->options['port']}", $this->options['user'], $this->options['pass'], array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8'));
+                }
+                catch (PDOException $e)
+                {
+                        $this->mysql = null;
+                        return;
+                }
+
+                $this->id = $name . $type;
+
+                if (!$query = $this->mysql->query('SHOW TABLES'))
+                {
+                        $this->mysql = null;
+                        return;
+                }
+
+                $db = array();
+                while ($row = $query->fetchColumn())
+                {
+                        $db[] = $row;
+                }
+
+                if (!in_array($this->options['extras']['prefix'] . 'cache_data', $db))
+                {
+                        $query = $this->mysql->exec('CREATE TABLE `' . $this->options['extras']['prefix'] . 'cache_data` (`id` TEXT CHARACTER SET utf8 NOT NULL, `items` SMALLINT NOT NULL DEFAULT 0, `data` BLOB NOT NULL, `mtime` INT UNSIGNED NOT NULL, UNIQUE (`id`(125)))');
+                        if ($query === false)
+                        {
+                                $this->mysql = null;
+                        }
+                }
+
+                if (!in_array($this->options['extras']['prefix'] . 'items', $db))
+                {
+                        $query = $this->mysql->exec('CREATE TABLE `' . $this->options['extras']['prefix'] . 'items` (`feed_id` TEXT CHARACTER SET utf8 NOT NULL, `id` TEXT CHARACTER SET utf8 NOT NULL, `data` TEXT CHARACTER SET utf8 NOT NULL, `posted` INT UNSIGNED NOT NULL, INDEX `feed_id` (`feed_id`(125)))');
+                        if ($query === false)
+                        {
+                                $this->mysql = null;
+                        }
+                }
+        }
+
+        /**
+         * Save data to the cache
+         *
+         * @param array|SimplePie $data Data to store in the cache. If passed a SimplePie object, only cache the $data property
+         * @return bool Successfulness
+         */
+        public function save($data)
+        {
+                if ($this->mysql === null)
+                {
+                        return false;
+                }
+
+                if ($data instanceof SimplePie)
+                {
+                        $data = clone $data;
+
+                        $prepared = self::prepare_simplepie_object_for_cache($data);
+
+                        $query = $this->mysql->prepare('SELECT COUNT(*) FROM `' . $this->options['extras']['prefix'] . 'cache_data` WHERE `id` = :feed');
+                        $query->bindValue(':feed', $this->id);
+                        if ($query->execute())
+                        {
+                                if ($query->fetchColumn() > 0)
+                                {
+                                        $items = count($prepared[1]);
+                                        if ($items)
+                                        {
+                                                $sql = 'UPDATE `' . $this->options['extras']['prefix'] . 'cache_data` SET `items` = :items, `data` = :data, `mtime` = :time WHERE `id` = :feed';
+                                                $query = $this->mysql->prepare($sql);
+                                                $query->bindValue(':items', $items);
+                                        }
+                                        else
+                                        {
+                                                $sql = 'UPDATE `' . $this->options['extras']['prefix'] . 'cache_data` SET `data` = :data, `mtime` = :time WHERE `id` = :feed';
+                                                $query = $this->mysql->prepare($sql);
+                                        }
+
+                                        $query->bindValue(':data', $prepared[0]);
+                                        $query->bindValue(':time', time());
+                                        $query->bindValue(':feed', $this->id);
+                                        if (!$query->execute())
+                                        {
+                                                return false;
+                                        }
+                                }
+                                else
+                                {
+                                        $query = $this->mysql->prepare('INSERT INTO `' . $this->options['extras']['prefix'] . 'cache_data` (`id`, `items`, `data`, `mtime`) VALUES(:feed, :count, :data, :time)');
+                                        $query->bindValue(':feed', $this->id);
+                                        $query->bindValue(':count', count($prepared[1]));
+                                        $query->bindValue(':data', $prepared[0]);
+                                        $query->bindValue(':time', time());
+                                        if (!$query->execute())
+                                        {
+                                                return false;
+                                        }
+                                }
+
+                                $ids = array_keys($prepared[1]);
+                                if (!empty($ids))
+                                {
+                                        foreach ($ids as $id)
+                                        {
+                                                $database_ids[] = $this->mysql->quote($id);
+                                        }
+
+                                        $query = $this->mysql->prepare('SELECT `id` FROM `' . $this->options['extras']['prefix'] . 'items` WHERE `id` = ' . implode(' OR `id` = ', $database_ids) . ' AND `feed_id` = :feed');
+                                        $query->bindValue(':feed', $this->id);
+
+                                        if ($query->execute())
+                                        {
+                                                $existing_ids = array();
+                                                while ($row = $query->fetchColumn())
+                                                {
+                                                        $existing_ids[] = $row;
+                                                }
+
+                                                $new_ids = array_diff($ids, $existing_ids);
+
+                                                foreach ($new_ids as $new_id)
+                                                {
+                                                        if (!($date = $prepared[1][$new_id]->get_date('U')))
+                                                        {
+                                                                $date = time();
+                                                        }
+
+                                                        $query = $this->mysql->prepare('INSERT INTO `' . $this->options['extras']['prefix'] . 'items` (`feed_id`, `id`, `data`, `posted`) VALUES(:feed, :id, :data, :date)');
+                                                        $query->bindValue(':feed', $this->id);
+                                                        $query->bindValue(':id', $new_id);
+                                                        $query->bindValue(':data', serialize($prepared[1][$new_id]->data));
+                                                        $query->bindValue(':date', $date);
+                                                        if (!$query->execute())
+                                                        {
+                                                                return false;
+                                                        }
+                                                }
+                                                return true;
+                                        }
+                                }
+                                else
+                                {
+                                        return true;
+                                }
+                        }
+                }
+                else
+                {
+                        $query = $this->mysql->prepare('SELECT `id` FROM `' . $this->options['extras']['prefix'] . 'cache_data` WHERE `id` = :feed');
+                        $query->bindValue(':feed', $this->id);
+                        if ($query->execute())
+                        {
+                                if ($query->rowCount() > 0)
+                                {
+                                        $query = $this->mysql->prepare('UPDATE `' . $this->options['extras']['prefix'] . 'cache_data` SET `items` = 0, `data` = :data, `mtime` = :time WHERE `id` = :feed');
+                                        $query->bindValue(':data', serialize($data));
+                                        $query->bindValue(':time', time());
+                                        $query->bindValue(':feed', $this->id);
+                                        if ($this->execute())
+                                        {
+                                                return true;
+                                        }
+                                }
+                                else
+                                {
+                                        $query = $this->mysql->prepare('INSERT INTO `' . $this->options['extras']['prefix'] . 'cache_data` (`id`, `items`, `data`, `mtime`) VALUES(:id, 0, :data, :time)');
+                                        $query->bindValue(':id', $this->id);
+                                        $query->bindValue(':data', serialize($data));
+                                        $query->bindValue(':time', time());
+                                        if ($query->execute())
+                                        {
+                                                return true;
+                                        }
+                                }
+                        }
+                }
+                return false;
+        }
+
+        /**
+         * Retrieve the data saved to the cache
+         *
+         * @return array Data for SimplePie::$data
+         */
+        public function load()
+        {
+                if ($this->mysql === null)
+                {
+                        return false;
+                }
+
+                $query = $this->mysql->prepare('SELECT `items`, `data` FROM `' . $this->options['extras']['prefix'] . 'cache_data` WHERE `id` = :id');
+                $query->bindValue(':id', $this->id);
+                if ($query->execute() && ($row = $query->fetch()))
+                {
+                        $data = unserialize($row[1]);
+
+                        if (isset($this->options['items'][0]))
+                        {
+                                $items = (int) $this->options['items'][0];
+                        }
+                        else
+                        {
+                                $items = (int) $row[0];
+                        }
+
+                        if ($items !== 0)
+                        {
+                                if (isset($data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]))
+                                {
+                                        $feed =& $data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0];
+                                }
+                                elseif (isset($data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]))
+                                {
+                                        $feed =& $data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0];
+                                }
+                                elseif (isset($data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]))
+                                {
+                                        $feed =& $data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0];
+                                }
+                                elseif (isset($data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]))
+                                {
+                                        $feed =& $data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0];
+                                }
+                                else
+                                {
+                                        $feed = null;
+                                }
+
+                                if ($feed !== null)
+                                {
+                                        $sql = 'SELECT `data` FROM `' . $this->options['extras']['prefix'] . 'items` WHERE `feed_id` = :feed ORDER BY `posted` DESC';
+                                        if ($items > 0)
+                                        {
+                                                $sql .= ' LIMIT ' . $items;
+                                        }
+
+                                        $query = $this->mysql->prepare($sql);
+                                        $query->bindValue(':feed', $this->id);
+                                        if ($query->execute())
+                                        {
+                                                while ($row = $query->fetchColumn())
+                                                {
+                                                        $feed['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['entry'][] = unserialize($row);
+                                                }
+                                        }
+                                        else
+                                        {
+                                                return false;
+                                        }
+                                }
+                        }
+                        return $data;
+                }
+                return false;
+        }
+
+        /**
+         * Retrieve the last modified time for the cache
+         *
+         * @return int Timestamp
+         */
+        public function mtime()
+        {
+                if ($this->mysql === null)
+                {
+                        return false;
+                }
+
+                $query = $this->mysql->prepare('SELECT `mtime` FROM `' . $this->options['extras']['prefix'] . 'cache_data` WHERE `id` = :id');
+                $query->bindValue(':id', $this->id);
+                if ($query->execute() && ($time = $query->fetchColumn()))
+                {
+                        return $time;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Set the last modified time to the current time
+         *
+         * @return bool Success status
+         */
+        public function touch()
+        {
+                if ($this->mysql === null)
+                {
+                        return false;
+                }
+
+                $query = $this->mysql->prepare('UPDATE `' . $this->options['extras']['prefix'] . 'cache_data` SET `mtime` = :time WHERE `id` = :id');
+                $query->bindValue(':time', time());
+                $query->bindValue(':id', $this->id);
+                if ($query->execute() && $query->rowCount() > 0)
+                {
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Remove the cache
+         *
+         * @return bool Success status
+         */
+        public function unlink()
+        {
+                if ($this->mysql === null)
+                {
+                        return false;
+                }
+
+                $query = $this->mysql->prepare('DELETE FROM `' . $this->options['extras']['prefix'] . 'cache_data` WHERE `id` = :id');
+                $query->bindValue(':id', $this->id);
+                $query2 = $this->mysql->prepare('DELETE FROM `' . $this->options['extras']['prefix'] . 'items` WHERE `feed_id` = :id');
+                $query2->bindValue(':id', $this->id);
+                if ($query->execute() && $query2->execute())
+                {
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Caption.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Caption.php
new file mode 100644
index 00000000..52922c5d
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Caption.php
@@ -0,0 +1,210 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Handles `<media:text>` captions as defined in Media RSS.
+ *
+ * Used by {@see SimplePie_Enclosure::get_caption()} and {@see SimplePie_Enclosure::get_captions()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_caption_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Caption
+{
+        /**
+         * Content type
+         *
+         * @var string
+         * @see get_type()
+         */
+        var $type;
+
+        /**
+         * Language
+         *
+         * @var string
+         * @see get_language()
+         */
+        var $lang;
+
+        /**
+         * Start time
+         *
+         * @var string
+         * @see get_starttime()
+         */
+        var $startTime;
+
+        /**
+         * End time
+         *
+         * @var string
+         * @see get_endtime()
+         */
+        var $endTime;
+
+        /**
+         * Caption text
+         *
+         * @var string
+         * @see get_text()
+         */
+        var $text;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         */
+        public function __construct($type = null, $lang = null, $startTime = null, $endTime = null, $text = null)
+        {
+                $this->type = $type;
+                $this->lang = $lang;
+                $this->startTime = $startTime;
+                $this->endTime = $endTime;
+                $this->text = $text;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the end time
+         *
+         * @return string|null Time in the format 'hh:mm:ss.SSS'
+         */
+        public function get_endtime()
+        {
+                if ($this->endTime !== null)
+                {
+                        return $this->endTime;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the language
+         *
+         * @link http://tools.ietf.org/html/rfc3066
+         * @return string|null Language code as per RFC 3066
+         */
+        public function get_language()
+        {
+                if ($this->lang !== null)
+                {
+                        return $this->lang;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the start time
+         *
+         * @return string|null Time in the format 'hh:mm:ss.SSS'
+         */
+        public function get_starttime()
+        {
+                if ($this->startTime !== null)
+                {
+                        return $this->startTime;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the text of the caption
+         *
+         * @return string|null
+         */
+        public function get_text()
+        {
+                if ($this->text !== null)
+                {
+                        return $this->text;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the content type (not MIME type)
+         *
+         * @return string|null Either 'text' or 'html'
+         */
+        public function get_type()
+        {
+                if ($this->type !== null)
+                {
+                        return $this->type;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Category.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Category.php
new file mode 100644
index 00000000..ad0407b4
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Category.php
@@ -0,0 +1,157 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Manages all category-related data
+ *
+ * Used by {@see SimplePie_Item::get_category()} and {@see SimplePie_Item::get_categories()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_category_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Category
+{
+        /**
+         * Category identifier
+         *
+         * @var string
+         * @see get_term
+         */
+        var $term;
+
+        /**
+         * Categorization scheme identifier
+         *
+         * @var string
+         * @see get_scheme()
+         */
+        var $scheme;
+
+        /**
+         * Human readable label
+         *
+         * @var string
+         * @see get_label()
+         */
+        var $label;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * @param string $term
+         * @param string $scheme
+         * @param string $label
+         */
+        public function __construct($term = null, $scheme = null, $label = null)
+        {
+                $this->term = $term;
+                $this->scheme = $scheme;
+                $this->label = $label;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the category identifier
+         *
+         * @return string|null
+         */
+        public function get_term()
+        {
+                if ($this->term !== null)
+                {
+                        return $this->term;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the categorization scheme identifier
+         *
+         * @return string|null
+         */
+        public function get_scheme()
+        {
+                if ($this->scheme !== null)
+                {
+                        return $this->scheme;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the human readable label
+         *
+         * @return string|null
+         */
+        public function get_label()
+        {
+                if ($this->label !== null)
+                {
+                        return $this->label;
+                }
+                else
+                {
+                        return $this->get_term();
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Content/Type/Sniffer.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Content/Type/Sniffer.php
new file mode 100644
index 00000000..20d053dc
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Content/Type/Sniffer.php
@@ -0,0 +1,332 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Content-type sniffing
+ *
+ * Based on the rules in http://tools.ietf.org/html/draft-abarth-mime-sniff-06
+ *
+ * This is used since we can't always trust Content-Type headers, and is based
+ * upon the HTML5 parsing rules.
+ *
+ *
+ * This class can be overloaded with {@see SimplePie::set_content_type_sniffer_class()}
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ */
+class SimplePie_Content_Type_Sniffer
+{
+        /**
+         * File object
+         *
+         * @var SimplePie_File
+         */
+        var $file;
+
+        /**
+         * Create an instance of the class with the input file
+         *
+         * @param SimplePie_Content_Type_Sniffer $file Input file
+         */
+        public function __construct($file)
+        {
+                $this->file = $file;
+        }
+
+        /**
+         * Get the Content-Type of the specified file
+         *
+         * @return string Actual Content-Type
+         */
+        public function get_type()
+        {
+                if (isset($this->file->headers['content-type']))
+                {
+                        if (!isset($this->file->headers['content-encoding'])
+                                && ($this->file->headers['content-type'] === 'text/plain'
+                                        || $this->file->headers['content-type'] === 'text/plain; charset=ISO-8859-1'
+                                        || $this->file->headers['content-type'] === 'text/plain; charset=iso-8859-1'
+                                        || $this->file->headers['content-type'] === 'text/plain; charset=UTF-8'))
+                        {
+                                return $this->text_or_binary();
+                        }
+
+                        if (($pos = strpos($this->file->headers['content-type'], ';')) !== false)
+                        {
+                                $official = substr($this->file->headers['content-type'], 0, $pos);
+                        }
+                        else
+                        {
+                                $official = $this->file->headers['content-type'];
+                        }
+                        $official = trim(strtolower($official));
+
+                        if ($official === 'unknown/unknown'
+                                || $official === 'application/unknown')
+                        {
+                                return $this->unknown();
+                        }
+                        elseif (substr($official, -4) === '+xml'
+                                || $official === 'text/xml'
+                                || $official === 'application/xml')
+                        {
+                                return $official;
+                        }
+                        elseif (substr($official, 0, 6) === 'image/')
+                        {
+                                if ($return = $this->image())
+                                {
+                                        return $return;
+                                }
+                                else
+                                {
+                                        return $official;
+                                }
+                        }
+                        elseif ($official === 'text/html')
+                        {
+                                return $this->feed_or_html();
+                        }
+                        else
+                        {
+                                return $official;
+                        }
+                }
+                else
+                {
+                        return $this->unknown();
+                }
+        }
+
+        /**
+         * Sniff text or binary
+         *
+         * @return string Actual Content-Type
+         */
+        public function text_or_binary()
+        {
+                if (substr($this->file->body, 0, 2) === "\xFE\xFF"
+                        || substr($this->file->body, 0, 2) === "\xFF\xFE"
+                        || substr($this->file->body, 0, 4) === "\x00\x00\xFE\xFF"
+                        || substr($this->file->body, 0, 3) === "\xEF\xBB\xBF")
+                {
+                        return 'text/plain';
+                }
+                elseif (preg_match('/[\x00-\x08\x0E-\x1A\x1C-\x1F]/', $this->file->body))
+                {
+                        return 'application/octect-stream';
+                }
+                else
+                {
+                        return 'text/plain';
+                }
+        }
+
+        /**
+         * Sniff unknown
+         *
+         * @return string Actual Content-Type
+         */
+        public function unknown()
+        {
+                $ws = strspn($this->file->body, "\x09\x0A\x0B\x0C\x0D\x20");
+                if (strtolower(substr($this->file->body, $ws, 14)) === '<!doctype html'
+                        || strtolower(substr($this->file->body, $ws, 5)) === '<html'
+                        || strtolower(substr($this->file->body, $ws, 7)) === '<script')
+                {
+                        return 'text/html';
+                }
+                elseif (substr($this->file->body, 0, 5) === '%PDF-')
+                {
+                        return 'application/pdf';
+                }
+                elseif (substr($this->file->body, 0, 11) === '%!PS-Adobe-')
+                {
+                        return 'application/postscript';
+                }
+                elseif (substr($this->file->body, 0, 6) === 'GIF87a'
+                        || substr($this->file->body, 0, 6) === 'GIF89a')
+                {
+                        return 'image/gif';
+                }
+                elseif (substr($this->file->body, 0, 8) === "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A")
+                {
+                        return 'image/png';
+                }
+                elseif (substr($this->file->body, 0, 3) === "\xFF\xD8\xFF")
+                {
+                        return 'image/jpeg';
+                }
+                elseif (substr($this->file->body, 0, 2) === "\x42\x4D")
+                {
+                        return 'image/bmp';
+                }
+                elseif (substr($this->file->body, 0, 4) === "\x00\x00\x01\x00")
+                {
+                        return 'image/vnd.microsoft.icon';
+                }
+                else
+                {
+                        return $this->text_or_binary();
+                }
+        }
+
+        /**
+         * Sniff images
+         *
+         * @return string Actual Content-Type
+         */
+        public function image()
+        {
+                if (substr($this->file->body, 0, 6) === 'GIF87a'
+                        || substr($this->file->body, 0, 6) === 'GIF89a')
+                {
+                        return 'image/gif';
+                }
+                elseif (substr($this->file->body, 0, 8) === "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A")
+                {
+                        return 'image/png';
+                }
+                elseif (substr($this->file->body, 0, 3) === "\xFF\xD8\xFF")
+                {
+                        return 'image/jpeg';
+                }
+                elseif (substr($this->file->body, 0, 2) === "\x42\x4D")
+                {
+                        return 'image/bmp';
+                }
+                elseif (substr($this->file->body, 0, 4) === "\x00\x00\x01\x00")
+                {
+                        return 'image/vnd.microsoft.icon';
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Sniff HTML
+         *
+         * @return string Actual Content-Type
+         */
+        public function feed_or_html()
+        {
+                $len = strlen($this->file->body);
+                $pos = strspn($this->file->body, "\x09\x0A\x0D\x20");
+
+                while ($pos < $len)
+                {
+                        switch ($this->file->body[$pos])
+                        {
+                                case "\x09":
+                                case "\x0A":
+                                case "\x0D":
+                                case "\x20":
+                                        $pos += strspn($this->file->body, "\x09\x0A\x0D\x20", $pos);
+                                        continue 2;
+
+                                case '<':
+                                        $pos++;
+                                        break;
+
+                                default:
+                                        return 'text/html';
+                        }
+
+                        if (substr($this->file->body, $pos, 3) === '!--')
+                        {
+                                $pos += 3;
+                                if ($pos < $len && ($pos = strpos($this->file->body, '-->', $pos)) !== false)
+                                {
+                                        $pos += 3;
+                                }
+                                else
+                                {
+                                        return 'text/html';
+                                }
+                        }
+                        elseif (substr($this->file->body, $pos, 1) === '!')
+                        {
+                                if ($pos < $len && ($pos = strpos($this->file->body, '>', $pos)) !== false)
+                                {
+                                        $pos++;
+                                }
+                                else
+                                {
+                                        return 'text/html';
+                                }
+                        }
+                        elseif (substr($this->file->body, $pos, 1) === '?')
+                        {
+                                if ($pos < $len && ($pos = strpos($this->file->body, '?>', $pos)) !== false)
+                                {
+                                        $pos += 2;
+                                }
+                                else
+                                {
+                                        return 'text/html';
+                                }
+                        }
+                        elseif (substr($this->file->body, $pos, 3) === 'rss'
+                                || substr($this->file->body, $pos, 7) === 'rdf:RDF')
+                        {
+                                return 'application/rss+xml';
+                        }
+                        elseif (substr($this->file->body, $pos, 4) === 'feed')
+                        {
+                                return 'application/atom+xml';
+                        }
+                        else
+                        {
+                                return 'text/html';
+                        }
+                }
+
+                return 'text/html';
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Copyright.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Copyright.php
new file mode 100644
index 00000000..57c535a6
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Copyright.php
@@ -0,0 +1,130 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Manages `<media:copyright>` copyright tags as defined in Media RSS
+ *
+ * Used by {@see SimplePie_Enclosure::get_copyright()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_copyright_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Copyright
+{
+        /**
+         * Copyright URL
+         *
+         * @var string
+         * @see get_url()
+         */
+        var $url;
+
+        /**
+         * Attribution
+         *
+         * @var string
+         * @see get_attribution()
+         */
+        var $label;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         */
+        public function __construct($url = null, $label = null)
+        {
+                $this->url = $url;
+                $this->label = $label;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the copyright URL
+         *
+         * @return string|null URL to copyright information
+         */
+        public function get_url()
+        {
+                if ($this->url !== null)
+                {
+                        return $this->url;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the attribution text
+         *
+         * @return string|null
+         */
+        public function get_attribution()
+        {
+                if ($this->label !== null)
+                {
+                        return $this->label;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Core.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Core.php
new file mode 100644
index 00000000..46d99662
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Core.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2009, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * SimplePie class.
+ *
+ * Class for backward compatibility.
+ *
+ * @deprecated Use {@see SimplePie} directly
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Core extends SimplePie
+{
+
+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Credit.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Credit.php
new file mode 100644
index 00000000..d3a3442a
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Credit.php
@@ -0,0 +1,156 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles `<media:credit>` as defined in Media RSS
+ *
+ * Used by {@see SimplePie_Enclosure::get_credit()} and {@see SimplePie_Enclosure::get_credits()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_credit_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Credit
+{
+        /**
+         * Credited role
+         *
+         * @var string
+         * @see get_role()
+         */
+        var $role;
+
+        /**
+         * Organizational scheme
+         *
+         * @var string
+         * @see get_scheme()
+         */
+        var $scheme;
+
+        /**
+         * Credited name
+         *
+         * @var string
+         * @see get_name()
+         */
+        var $name;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         */
+        public function __construct($role = null, $scheme = null, $name = null)
+        {
+                $this->role = $role;
+                $this->scheme = $scheme;
+                $this->name = $name;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the role of the person receiving credit
+         *
+         * @return string|null
+         */
+        public function get_role()
+        {
+                if ($this->role !== null)
+                {
+                        return $this->role;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the organizational scheme
+         *
+         * @return string|null
+         */
+        public function get_scheme()
+        {
+                if ($this->scheme !== null)
+                {
+                        return $this->scheme;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the credited person/entity's name
+         *
+         * @return string|null
+         */
+        public function get_name()
+        {
+                if ($this->name !== null)
+                {
+                        return $this->name;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Decode/HTML/Entities.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Decode/HTML/Entities.php
new file mode 100644
index 00000000..069e8d8e
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Decode/HTML/Entities.php
@@ -0,0 +1,617 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Decode HTML Entities
+ *
+ * This implements HTML5 as of revision 967 (2007-06-28)
+ *
+ * @deprecated Use DOMDocument instead!
+ * @package SimplePie
+ */
+class SimplePie_Decode_HTML_Entities
+{
+        /**
+         * Data to be parsed
+         *
+         * @access private
+         * @var string
+         */
+        var $data = '';
+
+        /**
+         * Currently consumed bytes
+         *
+         * @access private
+         * @var string
+         */
+        var $consumed = '';
+
+        /**
+         * Position of the current byte being parsed
+         *
+         * @access private
+         * @var int
+         */
+        var $position = 0;
+
+        /**
+         * Create an instance of the class with the input data
+         *
+         * @access public
+         * @param string $data Input data
+         */
+        public function __construct($data)
+        {
+                $this->data = $data;
+        }
+
+        /**
+         * Parse the input data
+         *
+         * @access public
+         * @return string Output data
+         */
+        public function parse()
+        {
+                while (($this->position = strpos($this->data, '&', $this->position)) !== false)
+                {
+                        $this->consume();
+                        $this->entity();
+                        $this->consumed = '';
+                }
+                return $this->data;
+        }
+
+        /**
+         * Consume the next byte
+         *
+         * @access private
+         * @return mixed The next byte, or false, if there is no more data
+         */
+        public function consume()
+        {
+                if (isset($this->data[$this->position]))
+                {
+                        $this->consumed .= $this->data[$this->position];
+                        return $this->data[$this->position++];
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Consume a range of characters
+         *
+         * @access private
+         * @param string $chars Characters to consume
+         * @return mixed A series of characters that match the range, or false
+         */
+        public function consume_range($chars)
+        {
+                if ($len = strspn($this->data, $chars, $this->position))
+                {
+                        $data = substr($this->data, $this->position, $len);
+                        $this->consumed .= $data;
+                        $this->position += $len;
+                        return $data;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Unconsume one byte
+         *
+         * @access private
+         */
+        public function unconsume()
+        {
+                $this->consumed = substr($this->consumed, 0, -1);
+                $this->position--;
+        }
+
+        /**
+         * Decode an entity
+         *
+         * @access private
+         */
+        public function entity()
+        {
+                switch ($this->consume())
+                {
+                        case "\x09":
+                        case "\x0A":
+                        case "\x0B":
+                        case "\x0B":
+                        case "\x0C":
+                        case "\x20":
+                        case "\x3C":
+                        case "\x26":
+                        case false:
+                                break;
+
+                        case "\x23":
+                                switch ($this->consume())
+                                {
+                                        case "\x78":
+                                        case "\x58":
+                                                $range = '0123456789ABCDEFabcdef';
+                                                $hex = true;
+                                                break;
+
+                                        default:
+                                                $range = '0123456789';
+                                                $hex = false;
+                                                $this->unconsume();
+                                                break;
+                                }
+
+                                if ($codepoint = $this->consume_range($range))
+                                {
+                                        static $windows_1252_specials = array(0x0D => "\x0A", 0x80 => "\xE2\x82\xAC", 0x81 => "\xEF\xBF\xBD", 0x82 => "\xE2\x80\x9A", 0x83 => "\xC6\x92", 0x84 => "\xE2\x80\x9E", 0x85 => "\xE2\x80\xA6", 0x86 => "\xE2\x80\xA0", 0x87 => "\xE2\x80\xA1", 0x88 => "\xCB\x86", 0x89 => "\xE2\x80\xB0", 0x8A => "\xC5\xA0", 0x8B => "\xE2\x80\xB9", 0x8C => "\xC5\x92", 0x8D => "\xEF\xBF\xBD", 0x8E => "\xC5\xBD", 0x8F => "\xEF\xBF\xBD", 0x90 => "\xEF\xBF\xBD", 0x91 => "\xE2\x80\x98", 0x92 => "\xE2\x80\x99", 0x93 => "\xE2\x80\x9C", 0x94 => "\xE2\x80\x9D", 0x95 => "\xE2\x80\xA2", 0x96 => "\xE2\x80\x93", 0x97 => "\xE2\x80\x94", 0x98 => "\xCB\x9C", 0x99 => "\xE2\x84\xA2", 0x9A => "\xC5\xA1", 0x9B => "\xE2\x80\xBA", 0x9C => "\xC5\x93", 0x9D => "\xEF\xBF\xBD", 0x9E => "\xC5\xBE", 0x9F => "\xC5\xB8");
+
+                                        if ($hex)
+                                        {
+                                                $codepoint = hexdec($codepoint);
+                                        }
+                                        else
+                                        {
+                                                $codepoint = intval($codepoint);
+                                        }
+
+                                        if (isset($windows_1252_specials[$codepoint]))
+                                        {
+                                                $replacement = $windows_1252_specials[$codepoint];
+                                        }
+                                        else
+                                        {
+                                                $replacement = SimplePie_Misc::codepoint_to_utf8($codepoint);
+                                        }
+
+                                        if (!in_array($this->consume(), array(';', false), true))
+                                        {
+                                                $this->unconsume();
+                                        }
+
+                                        $consumed_length = strlen($this->consumed);
+                                        $this->data = substr_replace($this->data, $replacement, $this->position - $consumed_length, $consumed_length);
+                                        $this->position += strlen($replacement) - $consumed_length;
+                                }
+                                break;
+
+                        default:
+                                static $entities = array(
+                                        'Aacute' => "\xC3\x81",
+                                        'aacute' => "\xC3\xA1",
+                                        'Aacute;' => "\xC3\x81",
+                                        'aacute;' => "\xC3\xA1",
+                                        'Acirc' => "\xC3\x82",
+                                        'acirc' => "\xC3\xA2",
+                                        'Acirc;' => "\xC3\x82",
+                                        'acirc;' => "\xC3\xA2",
+                                        'acute' => "\xC2\xB4",
+                                        'acute;' => "\xC2\xB4",
+                                        'AElig' => "\xC3\x86",
+                                        'aelig' => "\xC3\xA6",
+                                        'AElig;' => "\xC3\x86",
+                                        'aelig;' => "\xC3\xA6",
+                                        'Agrave' => "\xC3\x80",
+                                        'agrave' => "\xC3\xA0",
+                                        'Agrave;' => "\xC3\x80",
+                                        'agrave;' => "\xC3\xA0",
+                                        'alefsym;' => "\xE2\x84\xB5",
+                                        'Alpha;' => "\xCE\x91",
+                                        'alpha;' => "\xCE\xB1",
+                                        'AMP' => "\x26",
+                                        'amp' => "\x26",
+                                        'AMP;' => "\x26",
+                                        'amp;' => "\x26",
+                                        'and;' => "\xE2\x88\xA7",
+                                        'ang;' => "\xE2\x88\xA0",
+                                        'apos;' => "\x27",
+                                        'Aring' => "\xC3\x85",
+                                        'aring' => "\xC3\xA5",
+                                        'Aring;' => "\xC3\x85",
+                                        'aring;' => "\xC3\xA5",
+                                        'asymp;' => "\xE2\x89\x88",
+                                        'Atilde' => "\xC3\x83",
+                                        'atilde' => "\xC3\xA3",
+                                        'Atilde;' => "\xC3\x83",
+                                        'atilde;' => "\xC3\xA3",
+                                        'Auml' => "\xC3\x84",
+                                        'auml' => "\xC3\xA4",
+                                        'Auml;' => "\xC3\x84",
+                                        'auml;' => "\xC3\xA4",
+                                        'bdquo;' => "\xE2\x80\x9E",
+                                        'Beta;' => "\xCE\x92",
+                                        'beta;' => "\xCE\xB2",
+                                        'brvbar' => "\xC2\xA6",
+                                        'brvbar;' => "\xC2\xA6",
+                                        'bull;' => "\xE2\x80\xA2",
+                                        'cap;' => "\xE2\x88\xA9",
+                                        'Ccedil' => "\xC3\x87",
+                                        'ccedil' => "\xC3\xA7",
+                                        'Ccedil;' => "\xC3\x87",
+                                        'ccedil;' => "\xC3\xA7",
+                                        'cedil' => "\xC2\xB8",
+                                        'cedil;' => "\xC2\xB8",
+                                        'cent' => "\xC2\xA2",
+                                        'cent;' => "\xC2\xA2",
+                                        'Chi;' => "\xCE\xA7",
+                                        'chi;' => "\xCF\x87",
+                                        'circ;' => "\xCB\x86",
+                                        'clubs;' => "\xE2\x99\xA3",
+                                        'cong;' => "\xE2\x89\x85",
+                                        'COPY' => "\xC2\xA9",
+                                        'copy' => "\xC2\xA9",
+                                        'COPY;' => "\xC2\xA9",
+                                        'copy;' => "\xC2\xA9",
+                                        'crarr;' => "\xE2\x86\xB5",
+                                        'cup;' => "\xE2\x88\xAA",
+                                        'curren' => "\xC2\xA4",
+                                        'curren;' => "\xC2\xA4",
+                                        'Dagger;' => "\xE2\x80\xA1",
+                                        'dagger;' => "\xE2\x80\xA0",
+                                        'dArr;' => "\xE2\x87\x93",
+                                        'darr;' => "\xE2\x86\x93",
+                                        'deg' => "\xC2\xB0",
+                                        'deg;' => "\xC2\xB0",
+                                        'Delta;' => "\xCE\x94",
+                                        'delta;' => "\xCE\xB4",
+                                        'diams;' => "\xE2\x99\xA6",
+                                        'divide' => "\xC3\xB7",
+                                        'divide;' => "\xC3\xB7",
+                                        'Eacute' => "\xC3\x89",
+                                        'eacute' => "\xC3\xA9",
+                                        'Eacute;' => "\xC3\x89",
+                                        'eacute;' => "\xC3\xA9",
+                                        'Ecirc' => "\xC3\x8A",
+                                        'ecirc' => "\xC3\xAA",
+                                        'Ecirc;' => "\xC3\x8A",
+                                        'ecirc;' => "\xC3\xAA",
+                                        'Egrave' => "\xC3\x88",
+                                        'egrave' => "\xC3\xA8",
+                                        'Egrave;' => "\xC3\x88",
+                                        'egrave;' => "\xC3\xA8",
+                                        'empty;' => "\xE2\x88\x85",
+                                        'emsp;' => "\xE2\x80\x83",
+                                        'ensp;' => "\xE2\x80\x82",
+                                        'Epsilon;' => "\xCE\x95",
+                                        'epsilon;' => "\xCE\xB5",
+                                        'equiv;' => "\xE2\x89\xA1",
+                                        'Eta;' => "\xCE\x97",
+                                        'eta;' => "\xCE\xB7",
+                                        'ETH' => "\xC3\x90",
+                                        'eth' => "\xC3\xB0",
+                                        'ETH;' => "\xC3\x90",
+                                        'eth;' => "\xC3\xB0",
+                                        'Euml' => "\xC3\x8B",
+                                        'euml' => "\xC3\xAB",
+                                        'Euml;' => "\xC3\x8B",
+                                        'euml;' => "\xC3\xAB",
+                                        'euro;' => "\xE2\x82\xAC",
+                                        'exist;' => "\xE2\x88\x83",
+                                        'fnof;' => "\xC6\x92",
+                                        'forall;' => "\xE2\x88\x80",
+                                        'frac12' => "\xC2\xBD",
+                                        'frac12;' => "\xC2\xBD",
+                                        'frac14' => "\xC2\xBC",
+                                        'frac14;' => "\xC2\xBC",
+                                        'frac34' => "\xC2\xBE",
+                                        'frac34;' => "\xC2\xBE",
+                                        'frasl;' => "\xE2\x81\x84",
+                                        'Gamma;' => "\xCE\x93",
+                                        'gamma;' => "\xCE\xB3",
+                                        'ge;' => "\xE2\x89\xA5",
+                                        'GT' => "\x3E",
+                                        'gt' => "\x3E",
+                                        'GT;' => "\x3E",
+                                        'gt;' => "\x3E",
+                                        'hArr;' => "\xE2\x87\x94",
+                                        'harr;' => "\xE2\x86\x94",
+                                        'hearts;' => "\xE2\x99\xA5",
+                                        'hellip;' => "\xE2\x80\xA6",
+                                        'Iacute' => "\xC3\x8D",
+                                        'iacute' => "\xC3\xAD",
+                                        'Iacute;' => "\xC3\x8D",
+                                        'iacute;' => "\xC3\xAD",
+                                        'Icirc' => "\xC3\x8E",
+                                        'icirc' => "\xC3\xAE",
+                                        'Icirc;' => "\xC3\x8E",
+                                        'icirc;' => "\xC3\xAE",
+                                        'iexcl' => "\xC2\xA1",
+                                        'iexcl;' => "\xC2\xA1",
+                                        'Igrave' => "\xC3\x8C",
+                                        'igrave' => "\xC3\xAC",
+                                        'Igrave;' => "\xC3\x8C",
+                                        'igrave;' => "\xC3\xAC",
+                                        'image;' => "\xE2\x84\x91",
+                                        'infin;' => "\xE2\x88\x9E",
+                                        'int;' => "\xE2\x88\xAB",
+                                        'Iota;' => "\xCE\x99",
+                                        'iota;' => "\xCE\xB9",
+                                        'iquest' => "\xC2\xBF",
+                                        'iquest;' => "\xC2\xBF",
+                                        'isin;' => "\xE2\x88\x88",
+                                        'Iuml' => "\xC3\x8F",
+                                        'iuml' => "\xC3\xAF",
+                                        'Iuml;' => "\xC3\x8F",
+                                        'iuml;' => "\xC3\xAF",
+                                        'Kappa;' => "\xCE\x9A",
+                                        'kappa;' => "\xCE\xBA",
+                                        'Lambda;' => "\xCE\x9B",
+                                        'lambda;' => "\xCE\xBB",
+                                        'lang;' => "\xE3\x80\x88",
+                                        'laquo' => "\xC2\xAB",
+                                        'laquo;' => "\xC2\xAB",
+                                        'lArr;' => "\xE2\x87\x90",
+                                        'larr;' => "\xE2\x86\x90",
+                                        'lceil;' => "\xE2\x8C\x88",
+                                        'ldquo;' => "\xE2\x80\x9C",
+                                        'le;' => "\xE2\x89\xA4",
+                                        'lfloor;' => "\xE2\x8C\x8A",
+                                        'lowast;' => "\xE2\x88\x97",
+                                        'loz;' => "\xE2\x97\x8A",
+                                        'lrm;' => "\xE2\x80\x8E",
+                                        'lsaquo;' => "\xE2\x80\xB9",
+                                        'lsquo;' => "\xE2\x80\x98",
+                                        'LT' => "\x3C",
+                                        'lt' => "\x3C",
+                                        'LT;' => "\x3C",
+                                        'lt;' => "\x3C",
+                                        'macr' => "\xC2\xAF",
+                                        'macr;' => "\xC2\xAF",
+                                        'mdash;' => "\xE2\x80\x94",
+                                        'micro' => "\xC2\xB5",
+                                        'micro;' => "\xC2\xB5",
+                                        'middot' => "\xC2\xB7",
+                                        'middot;' => "\xC2\xB7",
+                                        'minus;' => "\xE2\x88\x92",
+                                        'Mu;' => "\xCE\x9C",
+                                        'mu;' => "\xCE\xBC",
+                                        'nabla;' => "\xE2\x88\x87",
+                                        'nbsp' => "\xC2\xA0",
+                                        'nbsp;' => "\xC2\xA0",
+                                        'ndash;' => "\xE2\x80\x93",
+                                        'ne;' => "\xE2\x89\xA0",
+                                        'ni;' => "\xE2\x88\x8B",
+                                        'not' => "\xC2\xAC",
+                                        'not;' => "\xC2\xAC",
+                                        'notin;' => "\xE2\x88\x89",
+                                        'nsub;' => "\xE2\x8A\x84",
+                                        'Ntilde' => "\xC3\x91",
+                                        'ntilde' => "\xC3\xB1",
+                                        'Ntilde;' => "\xC3\x91",
+                                        'ntilde;' => "\xC3\xB1",
+                                        'Nu;' => "\xCE\x9D",
+                                        'nu;' => "\xCE\xBD",
+                                        'Oacute' => "\xC3\x93",
+                                        'oacute' => "\xC3\xB3",
+                                        'Oacute;' => "\xC3\x93",
+                                        'oacute;' => "\xC3\xB3",
+                                        'Ocirc' => "\xC3\x94",
+                                        'ocirc' => "\xC3\xB4",
+                                        'Ocirc;' => "\xC3\x94",
+                                        'ocirc;' => "\xC3\xB4",
+                                        'OElig;' => "\xC5\x92",
+                                        'oelig;' => "\xC5\x93",
+                                        'Ograve' => "\xC3\x92",
+                                        'ograve' => "\xC3\xB2",
+                                        'Ograve;' => "\xC3\x92",
+                                        'ograve;' => "\xC3\xB2",
+                                        'oline;' => "\xE2\x80\xBE",
+                                        'Omega;' => "\xCE\xA9",
+                                        'omega;' => "\xCF\x89",
+                                        'Omicron;' => "\xCE\x9F",
+                                        'omicron;' => "\xCE\xBF",
+                                        'oplus;' => "\xE2\x8A\x95",
+                                        'or;' => "\xE2\x88\xA8",
+                                        'ordf' => "\xC2\xAA",
+                                        'ordf;' => "\xC2\xAA",
+                                        'ordm' => "\xC2\xBA",
+                                        'ordm;' => "\xC2\xBA",
+                                        'Oslash' => "\xC3\x98",
+                                        'oslash' => "\xC3\xB8",
+                                        'Oslash;' => "\xC3\x98",
+                                        'oslash;' => "\xC3\xB8",
+                                        'Otilde' => "\xC3\x95",
+                                        'otilde' => "\xC3\xB5",
+                                        'Otilde;' => "\xC3\x95",
+                                        'otilde;' => "\xC3\xB5",
+                                        'otimes;' => "\xE2\x8A\x97",
+                                        'Ouml' => "\xC3\x96",
+                                        'ouml' => "\xC3\xB6",
+                                        'Ouml;' => "\xC3\x96",
+                                        'ouml;' => "\xC3\xB6",
+                                        'para' => "\xC2\xB6",
+                                        'para;' => "\xC2\xB6",
+                                        'part;' => "\xE2\x88\x82",
+                                        'permil;' => "\xE2\x80\xB0",
+                                        'perp;' => "\xE2\x8A\xA5",
+                                        'Phi;' => "\xCE\xA6",
+                                        'phi;' => "\xCF\x86",
+                                        'Pi;' => "\xCE\xA0",
+                                        'pi;' => "\xCF\x80",
+                                        'piv;' => "\xCF\x96",
+                                        'plusmn' => "\xC2\xB1",
+                                        'plusmn;' => "\xC2\xB1",
+                                        'pound' => "\xC2\xA3",
+                                        'pound;' => "\xC2\xA3",
+                                        'Prime;' => "\xE2\x80\xB3",
+                                        'prime;' => "\xE2\x80\xB2",
+                                        'prod;' => "\xE2\x88\x8F",
+                                        'prop;' => "\xE2\x88\x9D",
+                                        'Psi;' => "\xCE\xA8",
+                                        'psi;' => "\xCF\x88",
+                                        'QUOT' => "\x22",
+                                        'quot' => "\x22",
+                                        'QUOT;' => "\x22",
+                                        'quot;' => "\x22",
+                                        'radic;' => "\xE2\x88\x9A",
+                                        'rang;' => "\xE3\x80\x89",
+                                        'raquo' => "\xC2\xBB",
+                                        'raquo;' => "\xC2\xBB",
+                                        'rArr;' => "\xE2\x87\x92",
+                                        'rarr;' => "\xE2\x86\x92",
+                                        'rceil;' => "\xE2\x8C\x89",
+                                        'rdquo;' => "\xE2\x80\x9D",
+                                        'real;' => "\xE2\x84\x9C",
+                                        'REG' => "\xC2\xAE",
+                                        'reg' => "\xC2\xAE",
+                                        'REG;' => "\xC2\xAE",
+                                        'reg;' => "\xC2\xAE",
+                                        'rfloor;' => "\xE2\x8C\x8B",
+                                        'Rho;' => "\xCE\xA1",
+                                        'rho;' => "\xCF\x81",
+                                        'rlm;' => "\xE2\x80\x8F",
+                                        'rsaquo;' => "\xE2\x80\xBA",
+                                        'rsquo;' => "\xE2\x80\x99",
+                                        'sbquo;' => "\xE2\x80\x9A",
+                                        'Scaron;' => "\xC5\xA0",
+                                        'scaron;' => "\xC5\xA1",
+                                        'sdot;' => "\xE2\x8B\x85",
+                                        'sect' => "\xC2\xA7",
+                                        'sect;' => "\xC2\xA7",
+                                        'shy' => "\xC2\xAD",
+                                        'shy;' => "\xC2\xAD",
+                                        'Sigma;' => "\xCE\xA3",
+                                        'sigma;' => "\xCF\x83",
+                                        'sigmaf;' => "\xCF\x82",
+                                        'sim;' => "\xE2\x88\xBC",
+                                        'spades;' => "\xE2\x99\xA0",
+                                        'sub;' => "\xE2\x8A\x82",
+                                        'sube;' => "\xE2\x8A\x86",
+                                        'sum;' => "\xE2\x88\x91",
+                                        'sup;' => "\xE2\x8A\x83",
+                                        'sup1' => "\xC2\xB9",
+                                        'sup1;' => "\xC2\xB9",
+                                        'sup2' => "\xC2\xB2",
+                                        'sup2;' => "\xC2\xB2",
+                                        'sup3' => "\xC2\xB3",
+                                        'sup3;' => "\xC2\xB3",
+                                        'supe;' => "\xE2\x8A\x87",
+                                        'szlig' => "\xC3\x9F",
+                                        'szlig;' => "\xC3\x9F",
+                                        'Tau;' => "\xCE\xA4",
+                                        'tau;' => "\xCF\x84",
+                                        'there4;' => "\xE2\x88\xB4",
+                                        'Theta;' => "\xCE\x98",
+                                        'theta;' => "\xCE\xB8",
+                                        'thetasym;' => "\xCF\x91",
+                                        'thinsp;' => "\xE2\x80\x89",
+                                        'THORN' => "\xC3\x9E",
+                                        'thorn' => "\xC3\xBE",
+                                        'THORN;' => "\xC3\x9E",
+                                        'thorn;' => "\xC3\xBE",
+                                        'tilde;' => "\xCB\x9C",
+                                        'times' => "\xC3\x97",
+                                        'times;' => "\xC3\x97",
+                                        'TRADE;' => "\xE2\x84\xA2",
+                                        'trade;' => "\xE2\x84\xA2",
+                                        'Uacute' => "\xC3\x9A",
+                                        'uacute' => "\xC3\xBA",
+                                        'Uacute;' => "\xC3\x9A",
+                                        'uacute;' => "\xC3\xBA",
+                                        'uArr;' => "\xE2\x87\x91",
+                                        'uarr;' => "\xE2\x86\x91",
+                                        'Ucirc' => "\xC3\x9B",
+                                        'ucirc' => "\xC3\xBB",
+                                        'Ucirc;' => "\xC3\x9B",
+                                        'ucirc;' => "\xC3\xBB",
+                                        'Ugrave' => "\xC3\x99",
+                                        'ugrave' => "\xC3\xB9",
+                                        'Ugrave;' => "\xC3\x99",
+                                        'ugrave;' => "\xC3\xB9",
+                                        'uml' => "\xC2\xA8",
+                                        'uml;' => "\xC2\xA8",
+                                        'upsih;' => "\xCF\x92",
+                                        'Upsilon;' => "\xCE\xA5",
+                                        'upsilon;' => "\xCF\x85",
+                                        'Uuml' => "\xC3\x9C",
+                                        'uuml' => "\xC3\xBC",
+                                        'Uuml;' => "\xC3\x9C",
+                                        'uuml;' => "\xC3\xBC",
+                                        'weierp;' => "\xE2\x84\x98",
+                                        'Xi;' => "\xCE\x9E",
+                                        'xi;' => "\xCE\xBE",
+                                        'Yacute' => "\xC3\x9D",
+                                        'yacute' => "\xC3\xBD",
+                                        'Yacute;' => "\xC3\x9D",
+                                        'yacute;' => "\xC3\xBD",
+                                        'yen' => "\xC2\xA5",
+                                        'yen;' => "\xC2\xA5",
+                                        'yuml' => "\xC3\xBF",
+                                        'Yuml;' => "\xC5\xB8",
+                                        'yuml;' => "\xC3\xBF",
+                                        'Zeta;' => "\xCE\x96",
+                                        'zeta;' => "\xCE\xB6",
+                                        'zwj;' => "\xE2\x80\x8D",
+                                        'zwnj;' => "\xE2\x80\x8C"
+                                );
+
+                                for ($i = 0, $match = null; $i < 9 && $this->consume() !== false; $i++)
+                                {
+                                        $consumed = substr($this->consumed, 1);
+                                        if (isset($entities[$consumed]))
+                                        {
+                                                $match = $consumed;
+                                        }
+                                }
+
+                                if ($match !== null)
+                                {
+                                        $this->data = substr_replace($this->data, $entities[$match], $this->position - strlen($consumed) - 1, strlen($match) + 1);
+                                        $this->position += strlen($entities[$match]) - strlen($consumed) - 1;
+                                }
+                                break;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Enclosure.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Enclosure.php
new file mode 100644
index 00000000..55674379
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Enclosure.php
@@ -0,0 +1,1380 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles everything related to enclosures (including Media RSS and iTunes RSS)
+ *
+ * Used by {@see SimplePie_Item::get_enclosure()} and {@see SimplePie_Item::get_enclosures()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_enclosure_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Enclosure
+{
+        /**
+         * @var string
+         * @see get_bitrate()
+         */
+        var $bitrate;
+
+        /**
+         * @var array
+         * @see get_captions()
+         */
+        var $captions;
+
+        /**
+         * @var array
+         * @see get_categories()
+         */
+        var $categories;
+
+        /**
+         * @var int
+         * @see get_channels()
+         */
+        var $channels;
+
+        /**
+         * @var SimplePie_Copyright
+         * @see get_copyright()
+         */
+        var $copyright;
+
+        /**
+         * @var array
+         * @see get_credits()
+         */
+        var $credits;
+
+        /**
+         * @var string
+         * @see get_description()
+         */
+        var $description;
+
+        /**
+         * @var int
+         * @see get_duration()
+         */
+        var $duration;
+
+        /**
+         * @var string
+         * @see get_expression()
+         */
+        var $expression;
+
+        /**
+         * @var string
+         * @see get_framerate()
+         */
+        var $framerate;
+
+        /**
+         * @var string
+         * @see get_handler()
+         */
+        var $handler;
+
+        /**
+         * @var array
+         * @see get_hashes()
+         */
+        var $hashes;
+
+        /**
+         * @var string
+         * @see get_height()
+         */
+        var $height;
+
+        /**
+         * @deprecated
+         * @var null
+         */
+        var $javascript;
+
+        /**
+         * @var array
+         * @see get_keywords()
+         */
+        var $keywords;
+
+        /**
+         * @var string
+         * @see get_language()
+         */
+        var $lang;
+
+        /**
+         * @var string
+         * @see get_length()
+         */
+        var $length;
+
+        /**
+         * @var string
+         * @see get_link()
+         */
+        var $link;
+
+        /**
+         * @var string
+         * @see get_medium()
+         */
+        var $medium;
+
+        /**
+         * @var string
+         * @see get_player()
+         */
+        var $player;
+
+        /**
+         * @var array
+         * @see get_ratings()
+         */
+        var $ratings;
+
+        /**
+         * @var array
+         * @see get_restrictions()
+         */
+        var $restrictions;
+
+        /**
+         * @var string
+         * @see get_sampling_rate()
+         */
+        var $samplingrate;
+
+        /**
+         * @var array
+         * @see get_thumbnails()
+         */
+        var $thumbnails;
+
+        /**
+         * @var string
+         * @see get_title()
+         */
+        var $title;
+
+        /**
+         * @var string
+         * @see get_type()
+         */
+        var $type;
+
+        /**
+         * @var string
+         * @see get_width()
+         */
+        var $width;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         *
+         * @uses idna_convert If available, this will convert an IDN
+         */
+        public function __construct($link = null, $type = null, $length = null, $javascript = null, $bitrate = null, $captions = null, $categories = null, $channels = null, $copyright = null, $credits = null, $description = null, $duration = null, $expression = null, $framerate = null, $hashes = null, $height = null, $keywords = null, $lang = null, $medium = null, $player = null, $ratings = null, $restrictions = null, $samplingrate = null, $thumbnails = null, $title = null, $width = null)
+        {
+                $this->bitrate = $bitrate;
+                $this->captions = $captions;
+                $this->categories = $categories;
+                $this->channels = $channels;
+                $this->copyright = $copyright;
+                $this->credits = $credits;
+                $this->description = $description;
+                $this->duration = $duration;
+                $this->expression = $expression;
+                $this->framerate = $framerate;
+                $this->hashes = $hashes;
+                $this->height = $height;
+                $this->keywords = $keywords;
+                $this->lang = $lang;
+                $this->length = $length;
+                $this->link = $link;
+                $this->medium = $medium;
+                $this->player = $player;
+                $this->ratings = $ratings;
+                $this->restrictions = $restrictions;
+                $this->samplingrate = $samplingrate;
+                $this->thumbnails = $thumbnails;
+                $this->title = $title;
+                $this->type = $type;
+                $this->width = $width;
+
+                if (class_exists('idna_convert'))
+                {
+                        $idn = new idna_convert();
+                        $parsed = SimplePie_Misc::parse_url($link);
+                        $this->link = SimplePie_Misc::compress_parse_url($parsed['scheme'], $idn->encode($parsed['authority']), $parsed['path'], $parsed['query'], $parsed['fragment']);
+                }
+                $this->handler = $this->get_handler(); // Needs to load last
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the bitrate
+         *
+         * @return string|null
+         */
+        public function get_bitrate()
+        {
+                if ($this->bitrate !== null)
+                {
+                        return $this->bitrate;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single caption
+         *
+         * @param int $key
+         * @return SimplePie_Caption|null
+         */
+        public function get_caption($key = 0)
+        {
+                $captions = $this->get_captions();
+                if (isset($captions[$key]))
+                {
+                        return $captions[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all captions
+         *
+         * @return array|null Array of {@see SimplePie_Caption} objects
+         */
+        public function get_captions()
+        {
+                if ($this->captions !== null)
+                {
+                        return $this->captions;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single category
+         *
+         * @param int $key
+         * @return SimplePie_Category|null
+         */
+        public function get_category($key = 0)
+        {
+                $categories = $this->get_categories();
+                if (isset($categories[$key]))
+                {
+                        return $categories[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all categories
+         *
+         * @return array|null Array of {@see SimplePie_Category} objects
+         */
+        public function get_categories()
+        {
+                if ($this->categories !== null)
+                {
+                        return $this->categories;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the number of audio channels
+         *
+         * @return int|null
+         */
+        public function get_channels()
+        {
+                if ($this->channels !== null)
+                {
+                        return $this->channels;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the copyright information
+         *
+         * @return SimplePie_Copyright|null
+         */
+        public function get_copyright()
+        {
+                if ($this->copyright !== null)
+                {
+                        return $this->copyright;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single credit
+         *
+         * @param int $key
+         * @return SimplePie_Credit|null
+         */
+        public function get_credit($key = 0)
+        {
+                $credits = $this->get_credits();
+                if (isset($credits[$key]))
+                {
+                        return $credits[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all credits
+         *
+         * @return array|null Array of {@see SimplePie_Credit} objects
+         */
+        public function get_credits()
+        {
+                if ($this->credits !== null)
+                {
+                        return $this->credits;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the description of the enclosure
+         *
+         * @return string|null
+         */
+        public function get_description()
+        {
+                if ($this->description !== null)
+                {
+                        return $this->description;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the duration of the enclosure
+         *
+         * @param string $convert Convert seconds into hh:mm:ss
+         * @return string|int|null 'hh:mm:ss' string if `$convert` was specified, otherwise integer (or null if none found)
+         */
+        public function get_duration($convert = false)
+        {
+                if ($this->duration !== null)
+                {
+                        if ($convert)
+                        {
+                                $time = SimplePie_Misc::time_hms($this->duration);
+                                return $time;
+                        }
+                        else
+                        {
+                                return $this->duration;
+                        }
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the expression
+         *
+         * @return string Probably one of 'sample', 'full', 'nonstop', 'clip'. Defaults to 'full'
+         */
+        public function get_expression()
+        {
+                if ($this->expression !== null)
+                {
+                        return $this->expression;
+                }
+                else
+                {
+                        return 'full';
+                }
+        }
+
+        /**
+         * Get the file extension
+         *
+         * @return string|null
+         */
+        public function get_extension()
+        {
+                if ($this->link !== null)
+                {
+                        $url = SimplePie_Misc::parse_url($this->link);
+                        if ($url['path'] !== '')
+                        {
+                                return pathinfo($url['path'], PATHINFO_EXTENSION);
+                        }
+                }
+                return null;
+        }
+
+        /**
+         * Get the framerate (in frames-per-second)
+         *
+         * @return string|null
+         */
+        public function get_framerate()
+        {
+                if ($this->framerate !== null)
+                {
+                        return $this->framerate;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the preferred handler
+         *
+         * @return string|null One of 'flash', 'fmedia', 'quicktime', 'wmedia', 'mp3'
+         */
+        public function get_handler()
+        {
+                return $this->get_real_type(true);
+        }
+
+        /**
+         * Get a single hash
+         *
+         * @link http://www.rssboard.org/media-rss#media-hash
+         * @param int $key
+         * @return string|null Hash as per `media:hash`, prefixed with "$algo:"
+         */
+        public function get_hash($key = 0)
+        {
+                $hashes = $this->get_hashes();
+                if (isset($hashes[$key]))
+                {
+                        return $hashes[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all credits
+         *
+         * @return array|null Array of strings, see {@see get_hash()}
+         */
+        public function get_hashes()
+        {
+                if ($this->hashes !== null)
+                {
+                        return $this->hashes;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the height
+         *
+         * @return string|null
+         */
+        public function get_height()
+        {
+                if ($this->height !== null)
+                {
+                        return $this->height;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the language
+         *
+         * @link http://tools.ietf.org/html/rfc3066
+         * @return string|null Language code as per RFC 3066
+         */
+        public function get_language()
+        {
+                if ($this->lang !== null)
+                {
+                        return $this->lang;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single keyword
+         *
+         * @param int $key
+         * @return string|null
+         */
+        public function get_keyword($key = 0)
+        {
+                $keywords = $this->get_keywords();
+                if (isset($keywords[$key]))
+                {
+                        return $keywords[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all keywords
+         *
+         * @return array|null Array of strings
+         */
+        public function get_keywords()
+        {
+                if ($this->keywords !== null)
+                {
+                        return $this->keywords;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get length
+         *
+         * @return float Length in bytes
+         */
+        public function get_length()
+        {
+                if ($this->length !== null)
+                {
+                        return $this->length;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the URL
+         *
+         * @return string|null
+         */
+        public function get_link()
+        {
+                if ($this->link !== null)
+                {
+                        return urldecode($this->link);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the medium
+         *
+         * @link http://www.rssboard.org/media-rss#media-content
+         * @return string|null Should be one of 'image', 'audio', 'video', 'document', 'executable'
+         */
+        public function get_medium()
+        {
+                if ($this->medium !== null)
+                {
+                        return $this->medium;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the player URL
+         *
+         * Typically the same as {@see get_permalink()}
+         * @return string|null Player URL
+         */
+        public function get_player()
+        {
+                if ($this->player !== null)
+                {
+                        return $this->player;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single rating
+         *
+         * @param int $key
+         * @return SimplePie_Rating|null
+         */
+        public function get_rating($key = 0)
+        {
+                $ratings = $this->get_ratings();
+                if (isset($ratings[$key]))
+                {
+                        return $ratings[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all ratings
+         *
+         * @return array|null Array of {@see SimplePie_Rating} objects
+         */
+        public function get_ratings()
+        {
+                if ($this->ratings !== null)
+                {
+                        return $this->ratings;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single restriction
+         *
+         * @param int $key
+         * @return SimplePie_Restriction|null
+         */
+        public function get_restriction($key = 0)
+        {
+                $restrictions = $this->get_restrictions();
+                if (isset($restrictions[$key]))
+                {
+                        return $restrictions[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all restrictions
+         *
+         * @return array|null Array of {@see SimplePie_Restriction} objects
+         */
+        public function get_restrictions()
+        {
+                if ($this->restrictions !== null)
+                {
+                        return $this->restrictions;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the sampling rate (in kHz)
+         *
+         * @return string|null
+         */
+        public function get_sampling_rate()
+        {
+                if ($this->samplingrate !== null)
+                {
+                        return $this->samplingrate;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the file size (in MiB)
+         *
+         * @return float|null File size in mebibytes (1048 bytes)
+         */
+        public function get_size()
+        {
+                $length = $this->get_length();
+                if ($length !== null)
+                {
+                        return round($length/1048576, 2);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single thumbnail
+         *
+         * @param int $key
+         * @return string|null Thumbnail URL
+         */
+        public function get_thumbnail($key = 0)
+        {
+                $thumbnails = $this->get_thumbnails();
+                if (isset($thumbnails[$key]))
+                {
+                        return $thumbnails[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all thumbnails
+         *
+         * @return array|null Array of thumbnail URLs
+         */
+        public function get_thumbnails()
+        {
+                if ($this->thumbnails !== null)
+                {
+                        return $this->thumbnails;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the title
+         *
+         * @return string|null
+         */
+        public function get_title()
+        {
+                if ($this->title !== null)
+                {
+                        return $this->title;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get mimetype of the enclosure
+         *
+         * @see get_real_type()
+         * @return string|null MIME type
+         */
+        public function get_type()
+        {
+                if ($this->type !== null)
+                {
+                        return $this->type;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the width
+         *
+         * @return string|null
+         */
+        public function get_width()
+        {
+                if ($this->width !== null)
+                {
+                        return $this->width;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Embed the enclosure using `<embed>`
+         *
+         * @deprecated Use the second parameter to {@see embed} instead
+         *
+         * @param array|string $options See first paramter to {@see embed}
+         * @return string HTML string to output
+         */
+        public function native_embed($options='')
+        {
+                return $this->embed($options, true);
+        }
+
+        /**
+         * Embed the enclosure using Javascript
+         *
+         * `$options` is an array or comma-separated key:value string, with the
+         * following properties:
+         *
+         * - `alt` (string): Alternate content for when an end-user does not have
+         *    the appropriate handler installed or when a file type is
+         *    unsupported. Can be any text or HTML. Defaults to blank.
+         * - `altclass` (string): If a file type is unsupported, the end-user will
+         *    see the alt text (above) linked directly to the content. That link
+         *    will have this value as its class name. Defaults to blank.
+         * - `audio` (string): This is an image that should be used as a
+         *    placeholder for audio files before they're loaded (QuickTime-only).
+         *    Can be any relative or absolute URL. Defaults to blank.
+         * - `bgcolor` (string): The background color for the media, if not
+         *    already transparent. Defaults to `#ffffff`.
+         * - `height` (integer): The height of the embedded media. Accepts any
+         *    numeric pixel value (such as `360`) or `auto`. Defaults to `auto`,
+         *    and it is recommended that you use this default.
+         * - `loop` (boolean): Do you want the media to loop when its done?
+         *    Defaults to `false`.
+         * - `mediaplayer` (string): The location of the included
+         *    `mediaplayer.swf` file. This allows for the playback of Flash Video
+         *    (`.flv`) files, and is the default handler for non-Odeo MP3's.
+         *    Defaults to blank.
+         * - `video` (string): This is an image that should be used as a
+         *    placeholder for video files before they're loaded (QuickTime-only).
+         *    Can be any relative or absolute URL. Defaults to blank.
+         * - `width` (integer): The width of the embedded media. Accepts any
+         *    numeric pixel value (such as `480`) or `auto`. Defaults to `auto`,
+         *    and it is recommended that you use this default.
+         * - `widescreen` (boolean): Is the enclosure widescreen or standard?
+         *    This applies only to video enclosures, and will automatically resize
+         *    the content appropriately.  Defaults to `false`, implying 4:3 mode.
+         *
+         * Note: Non-widescreen (4:3) mode with `width` and `height` set to `auto`
+         * will default to 480x360 video resolution.  Widescreen (16:9) mode with
+         * `width` and `height` set to `auto` will default to 480x270 video resolution.
+         *
+         * @todo If the dimensions for media:content are defined, use them when width/height are set to 'auto'.
+         * @param array|string $options Comma-separated key:value list, or array
+         * @param bool $native Use `<embed>`
+         * @return string HTML string to output
+         */
+        public function embed($options = '', $native = false)
+        {
+                // Set up defaults
+                $audio = '';
+                $video = '';
+                $alt = '';
+                $altclass = '';
+                $loop = 'false';
+                $width = 'auto';
+                $height = 'auto';
+                $bgcolor = '#ffffff';
+                $mediaplayer = '';
+                $widescreen = false;
+                $handler = $this->get_handler();
+                $type = $this->get_real_type();
+
+                // Process options and reassign values as necessary
+                if (is_array($options))
+                {
+                        extract($options);
+                }
+                else
+                {
+                        $options = explode(',', $options);
+                        foreach($options as $option)
+                        {
+                                $opt = explode(':', $option, 2);
+                                if (isset($opt[0], $opt[1]))
+                                {
+                                        $opt[0] = trim($opt[0]);
+                                        $opt[1] = trim($opt[1]);
+                                        switch ($opt[0])
+                                        {
+                                                case 'audio':
+                                                        $audio = $opt[1];
+                                                        break;
+
+                                                case 'video':
+                                                        $video = $opt[1];
+                                                        break;
+
+                                                case 'alt':
+                                                        $alt = $opt[1];
+                                                        break;
+
+                                                case 'altclass':
+                                                        $altclass = $opt[1];
+                                                        break;
+
+                                                case 'loop':
+                                                        $loop = $opt[1];
+                                                        break;
+
+                                                case 'width':
+                                                        $width = $opt[1];
+                                                        break;
+
+                                                case 'height':
+                                                        $height = $opt[1];
+                                                        break;
+
+                                                case 'bgcolor':
+                                                        $bgcolor = $opt[1];
+                                                        break;
+
+                                                case 'mediaplayer':
+                                                        $mediaplayer = $opt[1];
+                                                        break;
+
+                                                case 'widescreen':
+                                                        $widescreen = $opt[1];
+                                                        break;
+                                        }
+                                }
+                        }
+                }
+
+                $mime = explode('/', $type, 2);
+                $mime = $mime[0];
+
+                // Process values for 'auto'
+                if ($width === 'auto')
+                {
+                        if ($mime === 'video')
+                        {
+                                if ($height === 'auto')
+                                {
+                                        $width = 480;
+                                }
+                                elseif ($widescreen)
+                                {
+                                        $width = round((intval($height)/9)*16);
+                                }
+                                else
+                                {
+                                        $width = round((intval($height)/3)*4);
+                                }
+                        }
+                        else
+                        {
+                                $width = '100%';
+                        }
+                }
+
+                if ($height === 'auto')
+                {
+                        if ($mime === 'audio')
+                        {
+                                $height = 0;
+                        }
+                        elseif ($mime === 'video')
+                        {
+                                if ($width === 'auto')
+                                {
+                                        if ($widescreen)
+                                        {
+                                                $height = 270;
+                                        }
+                                        else
+                                        {
+                                                $height = 360;
+                                        }
+                                }
+                                elseif ($widescreen)
+                                {
+                                        $height = round((intval($width)/16)*9);
+                                }
+                                else
+                                {
+                                        $height = round((intval($width)/4)*3);
+                                }
+                        }
+                        else
+                        {
+                                $height = 376;
+                        }
+                }
+                elseif ($mime === 'audio')
+                {
+                        $height = 0;
+                }
+
+                // Set proper placeholder value
+                if ($mime === 'audio')
+                {
+                        $placeholder = $audio;
+                }
+                elseif ($mime === 'video')
+                {
+                        $placeholder = $video;
+                }
+
+                $embed = '';
+
+                // Flash
+                if ($handler === 'flash')
+                {
+                        if ($native)
+                        {
+                                $embed .= "<embed src=\"" . $this->get_link() . "\" pluginspage=\"http://adobe.com/go/getflashplayer\" type=\"$type\" quality=\"high\" width=\"$width\" height=\"$height\" bgcolor=\"$bgcolor\" loop=\"$loop\"></embed>";
+                        }
+                        else
+                        {
+                                $embed .= "<script type='text/javascript'>embed_flash('$bgcolor', '$width', '$height', '" . $this->get_link() . "', '$loop', '$type');</script>";
+                        }
+                }
+
+                // Flash Media Player file types.
+                // Preferred handler for MP3 file types.
+                elseif ($handler === 'fmedia' || ($handler === 'mp3' && $mediaplayer !== ''))
+                {
+                        $height += 20;
+                        if ($native)
+                        {
+                                $embed .= "<embed src=\"$mediaplayer\" pluginspage=\"http://adobe.com/go/getflashplayer\" type=\"application/x-shockwave-flash\" quality=\"high\" width=\"$width\" height=\"$height\" wmode=\"transparent\" flashvars=\"file=" . rawurlencode($this->get_link().'?file_extension=.'.$this->get_extension()) . "&autostart=false&repeat=$loop&showdigits=true&showfsbutton=false\"></embed>";
+                        }
+                        else
+                        {
+                                $embed .= "<script type='text/javascript'>embed_flv('$width', '$height', '" . rawurlencode($this->get_link().'?file_extension=.'.$this->get_extension()) . "', '$placeholder', '$loop', '$mediaplayer');</script>";
+                        }
+                }
+
+                // QuickTime 7 file types.  Need to test with QuickTime 6.
+                // Only handle MP3's if the Flash Media Player is not present.
+                elseif ($handler === 'quicktime' || ($handler === 'mp3' && $mediaplayer === ''))
+                {
+                        $height += 16;
+                        if ($native)
+                        {
+                                if ($placeholder !== '')
+                                {
+                                        $embed .= "<embed type=\"$type\" style=\"cursor:hand; cursor:pointer;\" href=\"" . $this->get_link() . "\" src=\"$placeholder\" width=\"$width\" height=\"$height\" autoplay=\"false\" target=\"myself\" controller=\"false\" loop=\"$loop\" scale=\"aspect\" bgcolor=\"$bgcolor\" pluginspage=\"http://apple.com/quicktime/download/\"></embed>";
+                                }
+                                else
+                                {
+                                        $embed .= "<embed type=\"$type\" style=\"cursor:hand; cursor:pointer;\" src=\"" . $this->get_link() . "\" width=\"$width\" height=\"$height\" autoplay=\"false\" target=\"myself\" controller=\"true\" loop=\"$loop\" scale=\"aspect\" bgcolor=\"$bgcolor\" pluginspage=\"http://apple.com/quicktime/download/\"></embed>";
+                                }
+                        }
+                        else
+                        {
+                                $embed .= "<script type='text/javascript'>embed_quicktime('$type', '$bgcolor', '$width', '$height', '" . $this->get_link() . "', '$placeholder', '$loop');</script>";
+                        }
+                }
+
+                // Windows Media
+                elseif ($handler === 'wmedia')
+                {
+                        $height += 45;
+                        if ($native)
+                        {
+                                $embed .= "<embed type=\"application/x-mplayer2\" src=\"" . $this->get_link() . "\" autosize=\"1\" width=\"$width\" height=\"$height\" showcontrols=\"1\" showstatusbar=\"0\" showdisplay=\"0\" autostart=\"0\"></embed>";
+                        }
+                        else
+                        {
+                                $embed .= "<script type='text/javascript'>embed_wmedia('$width', '$height', '" . $this->get_link() . "');</script>";
+                        }
+                }
+
+                // Everything else
+                else $embed .= '<a href="' . $this->get_link() . '" class="' . $altclass . '">' . $alt . '</a>';
+
+                return $embed;
+        }
+
+        /**
+         * Get the real media type
+         *
+         * Often, feeds lie to us, necessitating a bit of deeper inspection. This
+         * converts types to their canonical representations based on the file
+         * extension
+         *
+         * @see get_type()
+         * @param bool $find_handler Internal use only, use {@see get_handler()} instead
+         * @return string MIME type
+         */
+        public function get_real_type($find_handler = false)
+        {
+                // Mime-types by handler.
+                $types_flash = array('application/x-shockwave-flash', 'application/futuresplash'); // Flash
+                $types_fmedia = array('video/flv', 'video/x-flv','flv-application/octet-stream'); // Flash Media Player
+                $types_quicktime = array('audio/3gpp', 'audio/3gpp2', 'audio/aac', 'audio/x-aac', 'audio/aiff', 'audio/x-aiff', 'audio/mid', 'audio/midi', 'audio/x-midi', 'audio/mp4', 'audio/m4a', 'audio/x-m4a', 'audio/wav', 'audio/x-wav', 'video/3gpp', 'video/3gpp2', 'video/m4v', 'video/x-m4v', 'video/mp4', 'video/mpeg', 'video/x-mpeg', 'video/quicktime', 'video/sd-video'); // QuickTime
+                $types_wmedia = array('application/asx', 'application/x-mplayer2', 'audio/x-ms-wma', 'audio/x-ms-wax', 'video/x-ms-asf-plugin', 'video/x-ms-asf', 'video/x-ms-wm', 'video/x-ms-wmv', 'video/x-ms-wvx'); // Windows Media
+                $types_mp3 = array('audio/mp3', 'audio/x-mp3', 'audio/mpeg', 'audio/x-mpeg'); // MP3
+
+                if ($this->get_type() !== null)
+                {
+                        $type = strtolower($this->type);
+                }
+                else
+                {
+                        $type = null;
+                }
+
+                // If we encounter an unsupported mime-type, check the file extension and guess intelligently.
+                if (!in_array($type, array_merge($types_flash, $types_fmedia, $types_quicktime, $types_wmedia, $types_mp3)))
+                {
+                        switch (strtolower($this->get_extension()))
+                        {
+                                // Audio mime-types
+                                case 'aac':
+                                case 'adts':
+                                        $type = 'audio/acc';
+                                        break;
+
+                                case 'aif':
+                                case 'aifc':
+                                case 'aiff':
+                                case 'cdda':
+                                        $type = 'audio/aiff';
+                                        break;
+
+                                case 'bwf':
+                                        $type = 'audio/wav';
+                                        break;
+
+                                case 'kar':
+                                case 'mid':
+                                case 'midi':
+                                case 'smf':
+                                        $type = 'audio/midi';
+                                        break;
+
+                                case 'm4a':
+                                        $type = 'audio/x-m4a';
+                                        break;
+
+                                case 'mp3':
+                                case 'swa':
+                                        $type = 'audio/mp3';
+                                        break;
+
+                                case 'wav':
+                                        $type = 'audio/wav';
+                                        break;
+
+                                case 'wax':
+                                        $type = 'audio/x-ms-wax';
+                                        break;
+
+                                case 'wma':
+                                        $type = 'audio/x-ms-wma';
+                                        break;
+
+                                // Video mime-types
+                                case '3gp':
+                                case '3gpp':
+                                        $type = 'video/3gpp';
+                                        break;
+
+                                case '3g2':
+                                case '3gp2':
+                                        $type = 'video/3gpp2';
+                                        break;
+
+                                case 'asf':
+                                        $type = 'video/x-ms-asf';
+                                        break;
+
+                                case 'flv':
+                                        $type = 'video/x-flv';
+                                        break;
+
+                                case 'm1a':
+                                case 'm1s':
+                                case 'm1v':
+                                case 'm15':
+                                case 'm75':
+                                case 'mp2':
+                                case 'mpa':
+                                case 'mpeg':
+                                case 'mpg':
+                                case 'mpm':
+                                case 'mpv':
+                                        $type = 'video/mpeg';
+                                        break;
+
+                                case 'm4v':
+                                        $type = 'video/x-m4v';
+                                        break;
+
+                                case 'mov':
+                                case 'qt':
+                                        $type = 'video/quicktime';
+                                        break;
+
+                                case 'mp4':
+                                case 'mpg4':
+                                        $type = 'video/mp4';
+                                        break;
+
+                                case 'sdv':
+                                        $type = 'video/sd-video';
+                                        break;
+
+                                case 'wm':
+                                        $type = 'video/x-ms-wm';
+                                        break;
+
+                                case 'wmv':
+                                        $type = 'video/x-ms-wmv';
+                                        break;
+
+                                case 'wvx':
+                                        $type = 'video/x-ms-wvx';
+                                        break;
+
+                                // Flash mime-types
+                                case 'spl':
+                                        $type = 'application/futuresplash';
+                                        break;
+
+                                case 'swf':
+                                        $type = 'application/x-shockwave-flash';
+                                        break;
+                        }
+                }
+
+                if ($find_handler)
+                {
+                        if (in_array($type, $types_flash))
+                        {
+                                return 'flash';
+                        }
+                        elseif (in_array($type, $types_fmedia))
+                        {
+                                return 'fmedia';
+                        }
+                        elseif (in_array($type, $types_quicktime))
+                        {
+                                return 'quicktime';
+                        }
+                        elseif (in_array($type, $types_wmedia))
+                        {
+                                return 'wmedia';
+                        }
+                        elseif (in_array($type, $types_mp3))
+                        {
+                                return 'mp3';
+                        }
+                        else
+                        {
+                                return null;
+                        }
+                }
+                else
+                {
+                        return $type;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Exception.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Exception.php
new file mode 100644
index 00000000..73e104d6
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Exception.php
@@ -0,0 +1,52 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.4-dev
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * General SimplePie exception class
+ *
+ * @package SimplePie
+ */
+class SimplePie_Exception extends Exception
+{
+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/File.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/File.php
new file mode 100644
index 00000000..b7d1a2ac
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/File.php
@@ -0,0 +1,292 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Used for fetching remote files and reading local files
+ *
+ * Supports HTTP 1.0 via cURL or fsockopen, with spotty HTTP 1.1 support
+ *
+ * This class can be overloaded with {@see SimplePie::set_file_class()}
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ * @todo Move to properly supporting RFC2616 (HTTP/1.1)
+ */
+class SimplePie_File
+{
+        var $url;
+        var $useragent;
+        var $success = true;
+        var $headers = array();
+        var $body;
+        var $status_code;
+        var $redirects = 0;
+        var $error;
+        var $method = SIMPLEPIE_FILE_SOURCE_NONE;
+
+        public function __construct($url, $timeout = 10, $redirects = 5, $headers = null, $useragent = null, $force_fsockopen = false)
+        {
+                if (class_exists('idna_convert'))
+                {
+                        $idn = new idna_convert();
+                        $parsed = SimplePie_Misc::parse_url($url);
+                        $url = SimplePie_Misc::compress_parse_url($parsed['scheme'], $idn->encode($parsed['authority']), $parsed['path'], $parsed['query'], $parsed['fragment']);
+                }
+                $this->url = $url;
+                $this->useragent = $useragent;
+                if (preg_match('/^http(s)?:\/\//i', $url))
+                {
+                        if ($useragent === null)
+                        {
+                                $useragent = ini_get('user_agent');
+                                $this->useragent = $useragent;
+                        }
+                        if (!is_array($headers))
+                        {
+                                $headers = array();
+                        }
+                        if (!$force_fsockopen && function_exists('curl_exec'))
+                        {
+                                $this->method = SIMPLEPIE_FILE_SOURCE_REMOTE | SIMPLEPIE_FILE_SOURCE_CURL;
+                                $fp = curl_init();
+                                $headers2 = array();
+                                foreach ($headers as $key => $value)
+                                {
+                                        $headers2[] = "$key: $value";
+                                }
+                                if (version_compare(SimplePie_Misc::get_curl_version(), '7.10.5', '>='))
+                                {
+                                        curl_setopt($fp, CURLOPT_ENCODING, '');
+                                }
+                                curl_setopt($fp, CURLOPT_URL, $url);
+                                curl_setopt($fp, CURLOPT_HEADER, 1);
+                                curl_setopt($fp, CURLOPT_RETURNTRANSFER, 1);
+                                curl_setopt($fp, CURLOPT_TIMEOUT, $timeout);
+                                curl_setopt($fp, CURLOPT_CONNECTTIMEOUT, $timeout);
+                                curl_setopt($fp, CURLOPT_REFERER, $url);
+                                curl_setopt($fp, CURLOPT_USERAGENT, $useragent);
+                                curl_setopt($fp, CURLOPT_HTTPHEADER, $headers2);
+                                if (!ini_get('open_basedir') && !ini_get('safe_mode') && version_compare(SimplePie_Misc::get_curl_version(), '7.15.2', '>='))
+                                {
+                                        curl_setopt($fp, CURLOPT_FOLLOWLOCATION, 1);
+                                        curl_setopt($fp, CURLOPT_MAXREDIRS, $redirects);
+                                }
+
+                                $this->headers = curl_exec($fp);
+                                if (curl_errno($fp) === 23 || curl_errno($fp) === 61)
+                                {
+                                        curl_setopt($fp, CURLOPT_ENCODING, 'none');
+                                        $this->headers = curl_exec($fp);
+                                }
+                                if (curl_errno($fp))
+                                {
+                                        $this->error = 'cURL error ' . curl_errno($fp) . ': ' . curl_error($fp);
+                                        $this->success = false;
+                                }
+                                else
+                                {
+                                        $info = curl_getinfo($fp);
+                                        curl_close($fp);
+                                        $this->headers = explode("\r\n\r\n", $this->headers, $info['redirect_count'] + 1);
+                                        $this->headers = array_pop($this->headers);
+                                        $parser = new SimplePie_HTTP_Parser($this->headers);
+                                        if ($parser->parse())
+                                        {
+                                                $this->headers = $parser->headers;
+                                                $this->body = $parser->body;
+                                                $this->status_code = $parser->status_code;
+                                                if ((in_array($this->status_code, array(300, 301, 302, 303, 307)) || $this->status_code > 307 && $this->status_code < 400) && isset($this->headers['location']) && $this->redirects < $redirects)
+                                                {
+                                                        $this->redirects++;
+                                                        $location = SimplePie_Misc::absolutize_url($this->headers['location'], $url);
+                                                        return $this->__construct($location, $timeout, $redirects, $headers, $useragent, $force_fsockopen);
+                                                }
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                $this->method = SIMPLEPIE_FILE_SOURCE_REMOTE | SIMPLEPIE_FILE_SOURCE_FSOCKOPEN;
+                                $url_parts = parse_url($url);
+                                $socket_host = $url_parts['host'];
+                                if (isset($url_parts['scheme']) && strtolower($url_parts['scheme']) === 'https')
+                                {
+                                        $socket_host = "ssl://$url_parts[host]";
+                                        $url_parts['port'] = 443;
+                                }
+                                if (!isset($url_parts['port']))
+                                {
+                                        $url_parts['port'] = 80;
+                                }
+                                $fp = @fsockopen($socket_host, $url_parts['port'], $errno, $errstr, $timeout);
+                                if (!$fp)
+                                {
+                                        $this->error = 'fsockopen error: ' . $errstr;
+                                        $this->success = false;
+                                }
+                                else
+                                {
+                                        stream_set_timeout($fp, $timeout);
+                                        if (isset($url_parts['path']))
+                                        {
+                                                if (isset($url_parts['query']))
+                                                {
+                                                        $get = "$url_parts[path]?$url_parts[query]";
+                                                }
+                                                else
+                                                {
+                                                        $get = $url_parts['path'];
+                                                }
+                                        }
+                                        else
+                                        {
+                                                $get = '/';
+                                        }
+                                        $out = "GET $get HTTP/1.1\r\n";
+                                        $out .= "Host: $url_parts[host]\r\n";
+                                        $out .= "User-Agent: $useragent\r\n";
+                                        if (extension_loaded('zlib'))
+                                        {
+                                                $out .= "Accept-Encoding: x-gzip,gzip,deflate\r\n";
+                                        }
+
+                                        if (isset($url_parts['user']) && isset($url_parts['pass']))
+                                        {
+                                                $out .= "Authorization: Basic " . base64_encode("$url_parts[user]:$url_parts[pass]") . "\r\n";
+                                        }
+                                        foreach ($headers as $key => $value)
+                                        {
+                                                $out .= "$key: $value\r\n";
+                                        }
+                                        $out .= "Connection: Close\r\n\r\n";
+                                        fwrite($fp, $out);
+
+                                        $info = stream_get_meta_data($fp);
+
+                                        $this->headers = '';
+                                        while (!$info['eof'] && !$info['timed_out'])
+                                        {
+                                                $this->headers .= fread($fp, 1160);
+                                                $info = stream_get_meta_data($fp);
+                                        }
+                                        if (!$info['timed_out'])
+                                        {
+                                                $parser = new SimplePie_HTTP_Parser($this->headers);
+                                                if ($parser->parse())
+                                                {
+                                                        $this->headers = $parser->headers;
+                                                        $this->body = $parser->body;
+                                                        $this->status_code = $parser->status_code;
+                                                        if ((in_array($this->status_code, array(300, 301, 302, 303, 307)) || $this->status_code > 307 && $this->status_code < 400) && isset($this->headers['location']) && $this->redirects < $redirects)
+                                                        {
+                                                                $this->redirects++;
+                                                                $location = SimplePie_Misc::absolutize_url($this->headers['location'], $url);
+                                                                return $this->__construct($location, $timeout, $redirects, $headers, $useragent, $force_fsockopen);
+                                                        }
+                                                        if (isset($this->headers['content-encoding']))
+                                                        {
+                                                                // Hey, we act dumb elsewhere, so let's do that here too
+                                                                switch (strtolower(trim($this->headers['content-encoding'], "\x09\x0A\x0D\x20")))
+                                                                {
+                                                                        case 'gzip':
+                                                                        case 'x-gzip':
+                                                                                $decoder = new SimplePie_gzdecode($this->body);
+                                                                                if (!$decoder->parse())
+                                                                                {
+                                                                                        $this->error = 'Unable to decode HTTP "gzip" stream';
+                                                                                        $this->success = false;
+                                                                                }
+                                                                                else
+                                                                                {
+                                                                                        $this->body = $decoder->data;
+                                                                                }
+                                                                                break;
+
+                                                                        case 'deflate':
+                                                                                if (($decompressed = gzinflate($this->body)) !== false)
+                                                                                {
+                                                                                        $this->body = $decompressed;
+                                                                                }
+                                                                                else if (($decompressed = gzuncompress($this->body)) !== false)
+                                                                                {
+                                                                                        $this->body = $decompressed;
+                                                                                }
+                                                                                else if (function_exists('gzdecode') && ($decompressed = gzdecode($this->body)) !== false)
+                                                                                {
+                                                                                        $this->body = $decompressed;
+                                                                                }
+                                                                                else
+                                                                                {
+                                                                                        $this->error = 'Unable to decode HTTP "deflate" stream';
+                                                                                        $this->success = false;
+                                                                                }
+                                                                                break;
+
+                                                                        default:
+                                                                                $this->error = 'Unknown content coding';
+                                                                                $this->success = false;
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                        else
+                                        {
+                                                $this->error = 'fsocket timed out';
+                                                $this->success = false;
+                                        }
+                                        fclose($fp);
+                                }
+                        }
+                }
+                else
+                {
+                        $this->method = SIMPLEPIE_FILE_SOURCE_LOCAL | SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS;
+                        if (!$this->body = file_get_contents($url))
+                        {
+                                $this->error = 'file_get_contents could not read the file';
+                                $this->success = false;
+                        }
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/HTTP/Parser.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/HTTP/Parser.php
new file mode 100644
index 00000000..bff2222b
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/HTTP/Parser.php
@@ -0,0 +1,500 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * HTTP Response Parser
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ */
+class SimplePie_HTTP_Parser
+{
+        /**
+         * HTTP Version
+         *
+         * @var float
+         */
+        public $http_version = 0.0;
+
+        /**
+         * Status code
+         *
+         * @var int
+         */
+        public $status_code = 0;
+
+        /**
+         * Reason phrase
+         *
+         * @var string
+         */
+        public $reason = '';
+
+        /**
+         * Key/value pairs of the headers
+         *
+         * @var array
+         */
+        public $headers = array();
+
+        /**
+         * Body of the response
+         *
+         * @var string
+         */
+        public $body = '';
+
+        /**
+         * Current state of the state machine
+         *
+         * @var string
+         */
+        protected $state = 'http_version';
+
+        /**
+         * Input data
+         *
+         * @var string
+         */
+        protected $data = '';
+
+        /**
+         * Input data length (to avoid calling strlen() everytime this is needed)
+         *
+         * @var int
+         */
+        protected $data_length = 0;
+
+        /**
+         * Current position of the pointer
+         *
+         * @var int
+         */
+        protected $position = 0;
+
+        /**
+         * Name of the hedaer currently being parsed
+         *
+         * @var string
+         */
+        protected $name = '';
+
+        /**
+         * Value of the hedaer currently being parsed
+         *
+         * @var string
+         */
+        protected $value = '';
+
+        /**
+         * Create an instance of the class with the input data
+         *
+         * @param string $data Input data
+         */
+        public function __construct($data)
+        {
+                $this->data = $data;
+                $this->data_length = strlen($this->data);
+        }
+
+        /**
+         * Parse the input data
+         *
+         * @return bool true on success, false on failure
+         */
+        public function parse()
+        {
+                while ($this->state && $this->state !== 'emit' && $this->has_data())
+                {
+                        $state = $this->state;
+                        $this->$state();
+                }
+                $this->data = '';
+                if ($this->state === 'emit' || $this->state === 'body')
+                {
+                        return true;
+                }
+                else
+                {
+                        $this->http_version = '';
+                        $this->status_code = '';
+                        $this->reason = '';
+                        $this->headers = array();
+                        $this->body = '';
+                        return false;
+                }
+        }
+
+        /**
+         * Check whether there is data beyond the pointer
+         *
+         * @return bool true if there is further data, false if not
+         */
+        protected function has_data()
+        {
+                return (bool) ($this->position < $this->data_length);
+        }
+
+        /**
+         * See if the next character is LWS
+         *
+         * @return bool true if the next character is LWS, false if not
+         */
+        protected function is_linear_whitespace()
+        {
+                return (bool) ($this->data[$this->position] === "\x09"
+                        || $this->data[$this->position] === "\x20"
+                        || ($this->data[$this->position] === "\x0A"
+                                && isset($this->data[$this->position + 1])
+                                && ($this->data[$this->position + 1] === "\x09" || $this->data[$this->position + 1] === "\x20")));
+        }
+
+        /**
+         * Parse the HTTP version
+         */
+        protected function http_version()
+        {
+                if (strpos($this->data, "\x0A") !== false && strtoupper(substr($this->data, 0, 5)) === 'HTTP/')
+                {
+                        $len = strspn($this->data, '0123456789.', 5);
+                        $this->http_version = substr($this->data, 5, $len);
+                        $this->position += 5 + $len;
+                        if (substr_count($this->http_version, '.') <= 1)
+                        {
+                                $this->http_version = (float) $this->http_version;
+                                $this->position += strspn($this->data, "\x09\x20", $this->position);
+                                $this->state = 'status';
+                        }
+                        else
+                        {
+                                $this->state = false;
+                        }
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        /**
+         * Parse the status code
+         */
+        protected function status()
+        {
+                if ($len = strspn($this->data, '0123456789', $this->position))
+                {
+                        $this->status_code = (int) substr($this->data, $this->position, $len);
+                        $this->position += $len;
+                        $this->state = 'reason';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        /**
+         * Parse the reason phrase
+         */
+        protected function reason()
+        {
+                $len = strcspn($this->data, "\x0A", $this->position);
+                $this->reason = trim(substr($this->data, $this->position, $len), "\x09\x0D\x20");
+                $this->position += $len + 1;
+                $this->state = 'new_line';
+        }
+
+        /**
+         * Deal with a new line, shifting data around as needed
+         */
+        protected function new_line()
+        {
+                $this->value = trim($this->value, "\x0D\x20");
+                if ($this->name !== '' && $this->value !== '')
+                {
+                        $this->name = strtolower($this->name);
+                        // We should only use the last Content-Type header. c.f. issue #1
+                        if (isset($this->headers[$this->name]) && $this->name !== 'content-type')
+                        {
+                                $this->headers[$this->name] .= ', ' . $this->value;
+                        }
+                        else
+                        {
+                                $this->headers[$this->name] = $this->value;
+                        }
+                }
+                $this->name = '';
+                $this->value = '';
+                if (substr($this->data[$this->position], 0, 2) === "\x0D\x0A")
+                {
+                        $this->position += 2;
+                        $this->state = 'body';
+                }
+                elseif ($this->data[$this->position] === "\x0A")
+                {
+                        $this->position++;
+                        $this->state = 'body';
+                }
+                else
+                {
+                        $this->state = 'name';
+                }
+        }
+
+        /**
+         * Parse a header name
+         */
+        protected function name()
+        {
+                $len = strcspn($this->data, "\x0A:", $this->position);
+                if (isset($this->data[$this->position + $len]))
+                {
+                        if ($this->data[$this->position + $len] === "\x0A")
+                        {
+                                $this->position += $len;
+                                $this->state = 'new_line';
+                        }
+                        else
+                        {
+                                $this->name = substr($this->data, $this->position, $len);
+                                $this->position += $len + 1;
+                                $this->state = 'value';
+                        }
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        /**
+         * Parse LWS, replacing consecutive LWS characters with a single space
+         */
+        protected function linear_whitespace()
+        {
+                do
+                {
+                        if (substr($this->data, $this->position, 2) === "\x0D\x0A")
+                        {
+                                $this->position += 2;
+                        }
+                        elseif ($this->data[$this->position] === "\x0A")
+                        {
+                                $this->position++;
+                        }
+                        $this->position += strspn($this->data, "\x09\x20", $this->position);
+                } while ($this->has_data() && $this->is_linear_whitespace());
+                $this->value .= "\x20";
+        }
+
+        /**
+         * See what state to move to while within non-quoted header values
+         */
+        protected function value()
+        {
+                if ($this->is_linear_whitespace())
+                {
+                        $this->linear_whitespace();
+                }
+                else
+                {
+                        switch ($this->data[$this->position])
+                        {
+                                case '"':
+                                        // Workaround for ETags: we have to include the quotes as
+                                        // part of the tag.
+                                        if (strtolower($this->name) === 'etag')
+                                        {
+                                                $this->value .= '"';
+                                                $this->position++;
+                                                $this->state = 'value_char';
+                                                break;
+                                        }
+                                        $this->position++;
+                                        $this->state = 'quote';
+                                        break;
+
+                                case "\x0A":
+                                        $this->position++;
+                                        $this->state = 'new_line';
+                                        break;
+
+                                default:
+                                        $this->state = 'value_char';
+                                        break;
+                        }
+                }
+        }
+
+        /**
+         * Parse a header value while outside quotes
+         */
+        protected function value_char()
+        {
+                $len = strcspn($this->data, "\x09\x20\x0A\"", $this->position);
+                $this->value .= substr($this->data, $this->position, $len);
+                $this->position += $len;
+                $this->state = 'value';
+        }
+
+        /**
+         * See what state to move to while within quoted header values
+         */
+        protected function quote()
+        {
+                if ($this->is_linear_whitespace())
+                {
+                        $this->linear_whitespace();
+                }
+                else
+                {
+                        switch ($this->data[$this->position])
+                        {
+                                case '"':
+                                        $this->position++;
+                                        $this->state = 'value';
+                                        break;
+
+                                case "\x0A":
+                                        $this->position++;
+                                        $this->state = 'new_line';
+                                        break;
+
+                                case '\\':
+                                        $this->position++;
+                                        $this->state = 'quote_escaped';
+                                        break;
+
+                                default:
+                                        $this->state = 'quote_char';
+                                        break;
+                        }
+                }
+        }
+
+        /**
+         * Parse a header value while within quotes
+         */
+        protected function quote_char()
+        {
+                $len = strcspn($this->data, "\x09\x20\x0A\"\\", $this->position);
+                $this->value .= substr($this->data, $this->position, $len);
+                $this->position += $len;
+                $this->state = 'value';
+        }
+
+        /**
+         * Parse an escaped character within quotes
+         */
+        protected function quote_escaped()
+        {
+                $this->value .= $this->data[$this->position];
+                $this->position++;
+                $this->state = 'quote';
+        }
+
+        /**
+         * Parse the body
+         */
+        protected function body()
+        {
+                $this->body = substr($this->data, $this->position);
+                if (!empty($this->headers['transfer-encoding']))
+                {
+                        unset($this->headers['transfer-encoding']);
+                        $this->state = 'chunked';
+                }
+                else
+                {
+                        $this->state = 'emit';
+                }
+        }
+
+        /**
+         * Parsed a "Transfer-Encoding: chunked" body
+         */
+        protected function chunked()
+        {
+                if (!preg_match('/^([0-9a-f]+)[^\r\n]*\r\n/i', trim($this->body)))
+                {
+                        $this->state = 'emit';
+                        return;
+                }
+
+                $decoded = '';
+                $encoded = $this->body;
+
+                while (true)
+                {
+                        $is_chunked = (bool) preg_match( '/^([0-9a-f]+)[^\r\n]*\r\n/i', $encoded, $matches );
+                        if (!$is_chunked)
+                        {
+                                // Looks like it's not chunked after all
+                                $this->state = 'emit';
+                                return;
+                        }
+
+                        $length = hexdec(trim($matches[1]));
+                        if ($length === 0)
+                        {
+                                // Ignore trailer headers
+                                $this->state = 'emit';
+                                $this->body = $decoded;
+                                return;
+                        }
+
+                        $chunk_length = strlen($matches[0]);
+                        $decoded .= $part = substr($encoded, $chunk_length, $length);
+                        $encoded = substr($encoded, $chunk_length + $length + 2);
+
+                        if (trim($encoded) === '0' || empty($encoded))
+                        {
+                                $this->state = 'emit';
+                                $this->body = $decoded;
+                                return;
+                        }
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/IRI.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/IRI.php
new file mode 100644
index 00000000..d3198c04
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/IRI.php
@@ -0,0 +1,1238 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * IRI parser/serialiser/normaliser
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ * @author Geoffrey Sneddon
+ * @author Steve Minutillo
+ * @author Ryan McCue
+ * @copyright 2007-2012 Geoffrey Sneddon, Steve Minutillo, Ryan McCue
+ * @license http://www.opensource.org/licenses/bsd-license.php
+ */
+class SimplePie_IRI
+{
+        /**
+         * Scheme
+         *
+         * @var string
+         */
+        protected $scheme = null;
+
+        /**
+         * User Information
+         *
+         * @var string
+         */
+        protected $iuserinfo = null;
+
+        /**
+         * ihost
+         *
+         * @var string
+         */
+        protected $ihost = null;
+
+        /**
+         * Port
+         *
+         * @var string
+         */
+        protected $port = null;
+
+        /**
+         * ipath
+         *
+         * @var string
+         */
+        protected $ipath = '';
+
+        /**
+         * iquery
+         *
+         * @var string
+         */
+        protected $iquery = null;
+
+        /**
+         * ifragment
+         *
+         * @var string
+         */
+        protected $ifragment = null;
+
+        /**
+         * Normalization database
+         *
+         * Each key is the scheme, each value is an array with each key as the IRI
+         * part and value as the default value for that part.
+         */
+        protected $normalization = array(
+                'acap' => array(
+                        'port' => 674
+                ),
+                'dict' => array(
+                        'port' => 2628
+                ),
+                'file' => array(
+                        'ihost' => 'localhost'
+                ),
+                'http' => array(
+                        'port' => 80,
+                        'ipath' => '/'
+                ),
+                'https' => array(
+                        'port' => 443,
+                        'ipath' => '/'
+                ),
+        );
+
+        /**
+         * Return the entire IRI when you try and read the object as a string
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                return $this->get_iri();
+        }
+
+        /**
+         * Overload __set() to provide access via properties
+         *
+         * @param string $name Property name
+         * @param mixed $value Property value
+         */
+        public function __set($name, $value)
+        {
+                if (method_exists($this, 'set_' . $name))
+                {
+                        call_user_func(array($this, 'set_' . $name), $value);
+                }
+                elseif (
+                           $name === 'iauthority'
+                        || $name === 'iuserinfo'
+                        || $name === 'ihost'
+                        || $name === 'ipath'
+                        || $name === 'iquery'
+                        || $name === 'ifragment'
+                )
+                {
+                        call_user_func(array($this, 'set_' . substr($name, 1)), $value);
+                }
+        }
+
+        /**
+         * Overload __get() to provide access via properties
+         *
+         * @param string $name Property name
+         * @return mixed
+         */
+        public function __get($name)
+        {
+                // isset() returns false for null, we don't want to do that
+                // Also why we use array_key_exists below instead of isset()
+                $props = get_object_vars($this);
+
+                if (
+                        $name === 'iri' ||
+                        $name === 'uri' ||
+                        $name === 'iauthority' ||
+                        $name === 'authority'
+                )
+                {
+                        $return = $this->{"get_$name"}();
+                }
+                elseif (array_key_exists($name, $props))
+                {
+                        $return = $this->$name;
+                }
+                // host -> ihost
+                elseif (($prop = 'i' . $name) && array_key_exists($prop, $props))
+                {
+                        $name = $prop;
+                        $return = $this->$prop;
+                }
+                // ischeme -> scheme
+                elseif (($prop = substr($name, 1)) && array_key_exists($prop, $props))
+                {
+                        $name = $prop;
+                        $return = $this->$prop;
+                }
+                else
+                {
+                        trigger_error('Undefined property: ' . get_class($this) . '::' . $name, E_USER_NOTICE);
+                        $return = null;
+                }
+
+                if ($return === null && isset($this->normalization[$this->scheme][$name]))
+                {
+                        return $this->normalization[$this->scheme][$name];
+                }
+                else
+                {
+                        return $return;
+                }
+        }
+
+        /**
+         * Overload __isset() to provide access via properties
+         *
+         * @param string $name Property name
+         * @return bool
+         */
+        public function __isset($name)
+        {
+                if (method_exists($this, 'get_' . $name) || isset($this->$name))
+                {
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Overload __unset() to provide access via properties
+         *
+         * @param string $name Property name
+         */
+        public function __unset($name)
+        {
+                if (method_exists($this, 'set_' . $name))
+                {
+                        call_user_func(array($this, 'set_' . $name), '');
+                }
+        }
+
+        /**
+         * Create a new IRI object, from a specified string
+         *
+         * @param string $iri
+         */
+        public function __construct($iri = null)
+        {
+                $this->set_iri($iri);
+        }
+
+        /**
+         * Create a new IRI object by resolving a relative IRI
+         *
+         * Returns false if $base is not absolute, otherwise an IRI.
+         *
+         * @param IRI|string $base (Absolute) Base IRI
+         * @param IRI|string $relative Relative IRI
+         * @return IRI|false
+         */
+        public static function absolutize($base, $relative)
+        {
+                if (!($relative instanceof SimplePie_IRI))
+                {
+                        $relative = new SimplePie_IRI($relative);
+                }
+                if (!$relative->is_valid())
+                {
+                        return false;
+                }
+                elseif ($relative->scheme !== null)
+                {
+                        return clone $relative;
+                }
+                else
+                {
+                        if (!($base instanceof SimplePie_IRI))
+                        {
+                                $base = new SimplePie_IRI($base);
+                        }
+                        if ($base->scheme !== null && $base->is_valid())
+                        {
+                                if ($relative->get_iri() !== '')
+                                {
+                                        if ($relative->iuserinfo !== null || $relative->ihost !== null || $relative->port !== null)
+                                        {
+                                                $target = clone $relative;
+                                                $target->scheme = $base->scheme;
+                                        }
+                                        else
+                                        {
+                                                $target = new SimplePie_IRI;
+                                                $target->scheme = $base->scheme;
+                                                $target->iuserinfo = $base->iuserinfo;
+                                                $target->ihost = $base->ihost;
+                                                $target->port = $base->port;
+                                                if ($relative->ipath !== '')
+                                                {
+                                                        if ($relative->ipath[0] === '/')
+                                                        {
+                                                                $target->ipath = $relative->ipath;
+                                                        }
+                                                        elseif (($base->iuserinfo !== null || $base->ihost !== null || $base->port !== null) && $base->ipath === '')
+                                                        {
+                                                                $target->ipath = '/' . $relative->ipath;
+                                                        }
+                                                        elseif (($last_segment = strrpos($base->ipath, '/')) !== false)
+                                                        {
+                                                                $target->ipath = substr($base->ipath, 0, $last_segment + 1) . $relative->ipath;
+                                                        }
+                                                        else
+                                                        {
+                                                                $target->ipath = $relative->ipath;
+                                                        }
+                                                        $target->ipath = $target->remove_dot_segments($target->ipath);
+                                                        $target->iquery = $relative->iquery;
+                                                }
+                                                else
+                                                {
+                                                        $target->ipath = $base->ipath;
+                                                        if ($relative->iquery !== null)
+                                                        {
+                                                                $target->iquery = $relative->iquery;
+                                                        }
+                                                        elseif ($base->iquery !== null)
+                                                        {
+                                                                $target->iquery = $base->iquery;
+                                                        }
+                                                }
+                                                $target->ifragment = $relative->ifragment;
+                                        }
+                                }
+                                else
+                                {
+                                        $target = clone $base;
+                                        $target->ifragment = null;
+                                }
+                                $target->scheme_normalization();
+                                return $target;
+                        }
+                        else
+                        {
+                                return false;
+                        }
+                }
+        }
+
+        /**
+         * Parse an IRI into scheme/authority/path/query/fragment segments
+         *
+         * @param string $iri
+         * @return array
+         */
+        protected function parse_iri($iri)
+        {
+                $iri = trim($iri, "\x20\x09\x0A\x0C\x0D");
+                if (preg_match('/^((?P<scheme>[^:\/?#]+):)?(\/\/(?P<authority>[^\/?#]*))?(?P<path>[^?#]*)(\?(?P<query>[^#]*))?(#(?P<fragment>.*))?$/', $iri, $match))
+                {
+                        if ($match[1] === '')
+                        {
+                                $match['scheme'] = null;
+                        }
+                        if (!isset($match[3]) || $match[3] === '')
+                        {
+                                $match['authority'] = null;
+                        }
+                        if (!isset($match[5]))
+                        {
+                                $match['path'] = '';
+                        }
+                        if (!isset($match[6]) || $match[6] === '')
+                        {
+                                $match['query'] = null;
+                        }
+                        if (!isset($match[8]) || $match[8] === '')
+                        {
+                                $match['fragment'] = null;
+                        }
+                        return $match;
+                }
+                else
+                {
+                        // This can occur when a paragraph is accidentally parsed as a URI
+                        return false;
+                }
+        }
+
+        /**
+         * Remove dot segments from a path
+         *
+         * @param string $input
+         * @return string
+         */
+        protected function remove_dot_segments($input)
+        {
+                $output = '';
+                while (strpos($input, './') !== false || strpos($input, '/.') !== false || $input === '.' || $input === '..')
+                {
+                        // A: If the input buffer begins with a prefix of "../" or "./", then remove that prefix from the input buffer; otherwise,
+                        if (strpos($input, '../') === 0)
+                        {
+                                $input = substr($input, 3);
+                        }
+                        elseif (strpos($input, './') === 0)
+                        {
+                                $input = substr($input, 2);
+                        }
+                        // B: if the input buffer begins with a prefix of "/./" or "/.", where "." is a complete path segment, then replace that prefix with "/" in the input buffer; otherwise,
+                        elseif (strpos($input, '/./') === 0)
+                        {
+                                $input = substr($input, 2);
+                        }
+                        elseif ($input === '/.')
+                        {
+                                $input = '/';
+                        }
+                        // C: if the input buffer begins with a prefix of "/../" or "/..", where ".." is a complete path segment, then replace that prefix with "/" in the input buffer and remove the last segment and its preceding "/" (if any) from the output buffer; otherwise,
+                        elseif (strpos($input, '/../') === 0)
+                        {
+                                $input = substr($input, 3);
+                                $output = substr_replace($output, '', strrpos($output, '/'));
+                        }
+                        elseif ($input === '/..')
+                        {
+                                $input = '/';
+                                $output = substr_replace($output, '', strrpos($output, '/'));
+                        }
+                        // D: if the input buffer consists only of "." or "..", then remove that from the input buffer; otherwise,
+                        elseif ($input === '.' || $input === '..')
+                        {
+                                $input = '';
+                        }
+                        // E: move the first path segment in the input buffer to the end of the output buffer, including the initial "/" character (if any) and any subsequent characters up to, but not including, the next "/" character or the end of the input buffer
+                        elseif (($pos = strpos($input, '/', 1)) !== false)
+                        {
+                                $output .= substr($input, 0, $pos);
+                                $input = substr_replace($input, '', 0, $pos);
+                        }
+                        else
+                        {
+                                $output .= $input;
+                                $input = '';
+                        }
+                }
+                return $output . $input;
+        }
+
+        /**
+         * Replace invalid character with percent encoding
+         *
+         * @param string $string Input string
+         * @param string $extra_chars Valid characters not in iunreserved or
+         *                            iprivate (this is ASCII-only)
+         * @param bool $iprivate Allow iprivate
+         * @return string
+         */
+        protected function replace_invalid_with_pct_encoding($string, $extra_chars, $iprivate = false)
+        {
+                // Normalize as many pct-encoded sections as possible
+                $string = preg_replace_callback('/(?:%[A-Fa-f0-9]{2})+/', array($this, 'remove_iunreserved_percent_encoded'), $string);
+
+                // Replace invalid percent characters
+                $string = preg_replace('/%(?![A-Fa-f0-9]{2})/', '%25', $string);
+
+                // Add unreserved and % to $extra_chars (the latter is safe because all
+                // pct-encoded sections are now valid).
+                $extra_chars .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~%';
+
+                // Now replace any bytes that aren't allowed with their pct-encoded versions
+                $position = 0;
+                $strlen = strlen($string);
+                while (($position += strspn($string, $extra_chars, $position)) < $strlen)
+                {
+                        $value = ord($string[$position]);
+
+                        // Start position
+                        $start = $position;
+
+                        // By default we are valid
+                        $valid = true;
+
+                        // No one byte sequences are valid due to the while.
+                        // Two byte sequence:
+                        if (($value & 0xE0) === 0xC0)
+                        {
+                                $character = ($value & 0x1F) << 6;
+                                $length = 2;
+                                $remaining = 1;
+                        }
+                        // Three byte sequence:
+                        elseif (($value & 0xF0) === 0xE0)
+                        {
+                                $character = ($value & 0x0F) << 12;
+                                $length = 3;
+                                $remaining = 2;
+                        }
+                        // Four byte sequence:
+                        elseif (($value & 0xF8) === 0xF0)
+                        {
+                                $character = ($value & 0x07) << 18;
+                                $length = 4;
+                                $remaining = 3;
+                        }
+                        // Invalid byte:
+                        else
+                        {
+                                $valid = false;
+                                $length = 1;
+                                $remaining = 0;
+                        }
+
+                        if ($remaining)
+                        {
+                                if ($position + $length <= $strlen)
+                                {
+                                        for ($position++; $remaining; $position++)
+                                        {
+                                                $value = ord($string[$position]);
+
+                                                // Check that the byte is valid, then add it to the character:
+                                                if (($value & 0xC0) === 0x80)
+                                                {
+                                                        $character |= ($value & 0x3F) << (--$remaining * 6);
+                                                }
+                                                // If it is invalid, count the sequence as invalid and reprocess the current byte:
+                                                else
+                                                {
+                                                        $valid = false;
+                                                        $position--;
+                                                        break;
+                                                }
+                                        }
+                                }
+                                else
+                                {
+                                        $position = $strlen - 1;
+                                        $valid = false;
+                                }
+                        }
+
+                        // Percent encode anything invalid or not in ucschar
+                        if (
+                                // Invalid sequences
+                                !$valid
+                                // Non-shortest form sequences are invalid
+                                || $length > 1 && $character <= 0x7F
+                                || $length > 2 && $character <= 0x7FF
+                                || $length > 3 && $character <= 0xFFFF
+                                // Outside of range of ucschar codepoints
+                                // Noncharacters
+                                || ($character & 0xFFFE) === 0xFFFE
+                                || $character >= 0xFDD0 && $character <= 0xFDEF
+                                || (
+                                        // Everything else not in ucschar
+                                           $character > 0xD7FF && $character < 0xF900
+                                        || $character < 0xA0
+                                        || $character > 0xEFFFD
+                                )
+                                && (
+                                        // Everything not in iprivate, if it applies
+                                           !$iprivate
+                                        || $character < 0xE000
+                                        || $character > 0x10FFFD
+                                )
+                        )
+                        {
+                                // If we were a character, pretend we weren't, but rather an error.
+                                if ($valid)
+                                        $position--;
+
+                                for ($j = $start; $j <= $position; $j++)
+                                {
+                                        $string = substr_replace($string, sprintf('%%%02X', ord($string[$j])), $j, 1);
+                                        $j += 2;
+                                        $position += 2;
+                                        $strlen += 2;
+                                }
+                        }
+                }
+
+                return $string;
+        }
+
+        /**
+         * Callback function for preg_replace_callback.
+         *
+         * Removes sequences of percent encoded bytes that represent UTF-8
+         * encoded characters in iunreserved
+         *
+         * @param array $match PCRE match
+         * @return string Replacement
+         */
+        protected function remove_iunreserved_percent_encoded($match)
+        {
+                // As we just have valid percent encoded sequences we can just explode
+                // and ignore the first member of the returned array (an empty string).
+                $bytes = explode('%', $match[0]);
+
+                // Initialize the new string (this is what will be returned) and that
+                // there are no bytes remaining in the current sequence (unsurprising
+                // at the first byte!).
+                $string = '';
+                $remaining = 0;
+
+                // Loop over each and every byte, and set $value to its value
+                for ($i = 1, $len = count($bytes); $i < $len; $i++)
+                {
+                        $value = hexdec($bytes[$i]);
+
+                        // If we're the first byte of sequence:
+                        if (!$remaining)
+                        {
+                                // Start position
+                                $start = $i;
+
+                                // By default we are valid
+                                $valid = true;
+
+                                // One byte sequence:
+                                if ($value <= 0x7F)
+                                {
+                                        $character = $value;
+                                        $length = 1;
+                                }
+                                // Two byte sequence:
+                                elseif (($value & 0xE0) === 0xC0)
+                                {
+                                        $character = ($value & 0x1F) << 6;
+                                        $length = 2;
+                                        $remaining = 1;
+                                }
+                                // Three byte sequence:
+                                elseif (($value & 0xF0) === 0xE0)
+                                {
+                                        $character = ($value & 0x0F) << 12;
+                                        $length = 3;
+                                        $remaining = 2;
+                                }
+                                // Four byte sequence:
+                                elseif (($value & 0xF8) === 0xF0)
+                                {
+                                        $character = ($value & 0x07) << 18;
+                                        $length = 4;
+                                        $remaining = 3;
+                                }
+                                // Invalid byte:
+                                else
+                                {
+                                        $valid = false;
+                                        $remaining = 0;
+                                }
+                        }
+                        // Continuation byte:
+                        else
+                        {
+                                // Check that the byte is valid, then add it to the character:
+                                if (($value & 0xC0) === 0x80)
+                                {
+                                        $remaining--;
+                                        $character |= ($value & 0x3F) << ($remaining * 6);
+                                }
+                                // If it is invalid, count the sequence as invalid and reprocess the current byte as the start of a sequence:
+                                else
+                                {
+                                        $valid = false;
+                                        $remaining = 0;
+                                        $i--;
+                                }
+                        }
+
+                        // If we've reached the end of the current byte sequence, append it to Unicode::$data
+                        if (!$remaining)
+                        {
+                                // Percent encode anything invalid or not in iunreserved
+                                if (
+                                        // Invalid sequences
+                                        !$valid
+                                        // Non-shortest form sequences are invalid
+                                        || $length > 1 && $character <= 0x7F
+                                        || $length > 2 && $character <= 0x7FF
+                                        || $length > 3 && $character <= 0xFFFF
+                                        // Outside of range of iunreserved codepoints
+                                        || $character < 0x2D
+                                        || $character > 0xEFFFD
+                                        // Noncharacters
+                                        || ($character & 0xFFFE) === 0xFFFE
+                                        || $character >= 0xFDD0 && $character <= 0xFDEF
+                                        // Everything else not in iunreserved (this is all BMP)
+                                        || $character === 0x2F
+                                        || $character > 0x39 && $character < 0x41
+                                        || $character > 0x5A && $character < 0x61
+                                        || $character > 0x7A && $character < 0x7E
+                                        || $character > 0x7E && $character < 0xA0
+                                        || $character > 0xD7FF && $character < 0xF900
+                                )
+                                {
+                                        for ($j = $start; $j <= $i; $j++)
+                                        {
+                                                $string .= '%' . strtoupper($bytes[$j]);
+                                        }
+                                }
+                                else
+                                {
+                                        for ($j = $start; $j <= $i; $j++)
+                                        {
+                                                $string .= chr(hexdec($bytes[$j]));
+                                        }
+                                }
+                        }
+                }
+
+                // If we have any bytes left over they are invalid (i.e., we are
+                // mid-way through a multi-byte sequence)
+                if ($remaining)
+                {
+                        for ($j = $start; $j < $len; $j++)
+                        {
+                                $string .= '%' . strtoupper($bytes[$j]);
+                        }
+                }
+
+                return $string;
+        }
+
+        protected function scheme_normalization()
+        {
+                if (isset($this->normalization[$this->scheme]['iuserinfo']) && $this->iuserinfo === $this->normalization[$this->scheme]['iuserinfo'])
+                {
+                        $this->iuserinfo = null;
+                }
+                if (isset($this->normalization[$this->scheme]['ihost']) && $this->ihost === $this->normalization[$this->scheme]['ihost'])
+                {
+                        $this->ihost = null;
+                }
+                if (isset($this->normalization[$this->scheme]['port']) && $this->port === $this->normalization[$this->scheme]['port'])
+                {
+                        $this->port = null;
+                }
+                if (isset($this->normalization[$this->scheme]['ipath']) && $this->ipath === $this->normalization[$this->scheme]['ipath'])
+                {
+                        $this->ipath = '';
+                }
+                if (isset($this->normalization[$this->scheme]['iquery']) && $this->iquery === $this->normalization[$this->scheme]['iquery'])
+                {
+                        $this->iquery = null;
+                }
+                if (isset($this->normalization[$this->scheme]['ifragment']) && $this->ifragment === $this->normalization[$this->scheme]['ifragment'])
+                {
+                        $this->ifragment = null;
+                }
+        }
+
+        /**
+         * Check if the object represents a valid IRI. This needs to be done on each
+         * call as some things change depending on another part of the IRI.
+         *
+         * @return bool
+         */
+        public function is_valid()
+        {
+                $isauthority = $this->iuserinfo !== null || $this->ihost !== null || $this->port !== null;
+                if ($this->ipath !== '' &&
+                        (
+                                $isauthority && (
+                                        $this->ipath[0] !== '/' ||
+                                        substr($this->ipath, 0, 2) === '//'
+                                ) ||
+                                (
+                                        $this->scheme === null &&
+                                        !$isauthority &&
+                                        strpos($this->ipath, ':') !== false &&
+                                        (strpos($this->ipath, '/') === false ? true : strpos($this->ipath, ':') < strpos($this->ipath, '/'))
+                                )
+                        )
+                )
+                {
+                        return false;
+                }
+
+                return true;
+        }
+
+        /**
+         * Set the entire IRI. Returns true on success, false on failure (if there
+         * are any invalid characters).
+         *
+         * @param string $iri
+         * @return bool
+         */
+        public function set_iri($iri)
+        {
+                static $cache;
+                if (!$cache)
+                {
+                        $cache = array();
+                }
+
+                if ($iri === null)
+                {
+                        return true;
+                }
+                elseif (isset($cache[$iri]))
+                {
+                        list($this->scheme,
+                                 $this->iuserinfo,
+                                 $this->ihost,
+                                 $this->port,
+                                 $this->ipath,
+                                 $this->iquery,
+                                 $this->ifragment,
+                                 $return) = $cache[$iri];
+                        return $return;
+                }
+                else
+                {
+                        $parsed = $this->parse_iri((string) $iri);
+                        if (!$parsed)
+                        {
+                                return false;
+                        }
+
+                        $return = $this->set_scheme($parsed['scheme'])
+                                && $this->set_authority($parsed['authority'])
+                                && $this->set_path($parsed['path'])
+                                && $this->set_query($parsed['query'])
+                                && $this->set_fragment($parsed['fragment']);
+
+                        $cache[$iri] = array($this->scheme,
+                                                                 $this->iuserinfo,
+                                                                 $this->ihost,
+                                                                 $this->port,
+                                                                 $this->ipath,
+                                                                 $this->iquery,
+                                                                 $this->ifragment,
+                                                                 $return);
+                        return $return;
+                }
+        }
+
+        /**
+         * Set the scheme. Returns true on success, false on failure (if there are
+         * any invalid characters).
+         *
+         * @param string $scheme
+         * @return bool
+         */
+        public function set_scheme($scheme)
+        {
+                if ($scheme === null)
+                {
+                        $this->scheme = null;
+                }
+                elseif (!preg_match('/^[A-Za-z][0-9A-Za-z+\-.]*$/', $scheme))
+                {
+                        $this->scheme = null;
+                        return false;
+                }
+                else
+                {
+                        $this->scheme = strtolower($scheme);
+                }
+                return true;
+        }
+
+        /**
+         * Set the authority. Returns true on success, false on failure (if there are
+         * any invalid characters).
+         *
+         * @param string $authority
+         * @return bool
+         */
+        public function set_authority($authority)
+        {
+                static $cache;
+                if (!$cache)
+                        $cache = array();
+
+                if ($authority === null)
+                {
+                        $this->iuserinfo = null;
+                        $this->ihost = null;
+                        $this->port = null;
+                        return true;
+                }
+                elseif (isset($cache[$authority]))
+                {
+                        list($this->iuserinfo,
+                                 $this->ihost,
+                                 $this->port,
+                                 $return) = $cache[$authority];
+
+                        return $return;
+                }
+                else
+                {
+                        $remaining = $authority;
+                        if (($iuserinfo_end = strrpos($remaining, '@')) !== false)
+                        {
+                                $iuserinfo = substr($remaining, 0, $iuserinfo_end);
+                                $remaining = substr($remaining, $iuserinfo_end + 1);
+                        }
+                        else
+                        {
+                                $iuserinfo = null;
+                        }
+                        if (($port_start = strpos($remaining, ':', strpos($remaining, ']'))) !== false)
+                        {
+                                if (($port = substr($remaining, $port_start + 1)) === false)
+                                {
+                                        $port = null;
+                                }
+                                $remaining = substr($remaining, 0, $port_start);
+                        }
+                        else
+                        {
+                                $port = null;
+                        }
+
+                        $return = $this->set_userinfo($iuserinfo) &&
+                                          $this->set_host($remaining) &&
+                                          $this->set_port($port);
+
+                        $cache[$authority] = array($this->iuserinfo,
+                                                                           $this->ihost,
+                                                                           $this->port,
+                                                                           $return);
+
+                        return $return;
+                }
+        }
+
+        /**
+         * Set the iuserinfo.
+         *
+         * @param string $iuserinfo
+         * @return bool
+         */
+        public function set_userinfo($iuserinfo)
+        {
+                if ($iuserinfo === null)
+                {
+                        $this->iuserinfo = null;
+                }
+                else
+                {
+                        $this->iuserinfo = $this->replace_invalid_with_pct_encoding($iuserinfo, '!$&\'()*+,;=:');
+                        $this->scheme_normalization();
+                }
+
+                return true;
+        }
+
+        /**
+         * Set the ihost. Returns true on success, false on failure (if there are
+         * any invalid characters).
+         *
+         * @param string $ihost
+         * @return bool
+         */
+        public function set_host($ihost)
+        {
+                if ($ihost === null)
+                {
+                        $this->ihost = null;
+                        return true;
+                }
+                elseif (substr($ihost, 0, 1) === '[' && substr($ihost, -1) === ']')
+                {
+                        if (SimplePie_Net_IPv6::check_ipv6(substr($ihost, 1, -1)))
+                        {
+                                $this->ihost = '[' . SimplePie_Net_IPv6::compress(substr($ihost, 1, -1)) . ']';
+                        }
+                        else
+                        {
+                                $this->ihost = null;
+                                return false;
+                        }
+                }
+                else
+                {
+                        $ihost = $this->replace_invalid_with_pct_encoding($ihost, '!$&\'()*+,;=');
+
+                        // Lowercase, but ignore pct-encoded sections (as they should
+                        // remain uppercase). This must be done after the previous step
+                        // as that can add unescaped characters.
+                        $position = 0;
+                        $strlen = strlen($ihost);
+                        while (($position += strcspn($ihost, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ%', $position)) < $strlen)
+                        {
+                                if ($ihost[$position] === '%')
+                                {
+                                        $position += 3;
+                                }
+                                else
+                                {
+                                        $ihost[$position] = strtolower($ihost[$position]);
+                                        $position++;
+                                }
+                        }
+
+                        $this->ihost = $ihost;
+                }
+
+                $this->scheme_normalization();
+
+                return true;
+        }
+
+        /**
+         * Set the port. Returns true on success, false on failure (if there are
+         * any invalid characters).
+         *
+         * @param string $port
+         * @return bool
+         */
+        public function set_port($port)
+        {
+                if ($port === null)
+                {
+                        $this->port = null;
+                        return true;
+                }
+                elseif (strspn($port, '0123456789') === strlen($port))
+                {
+                        $this->port = (int) $port;
+                        $this->scheme_normalization();
+                        return true;
+                }
+                else
+                {
+                        $this->port = null;
+                        return false;
+                }
+        }
+
+        /**
+         * Set the ipath.
+         *
+         * @param string $ipath
+         * @return bool
+         */
+        public function set_path($ipath)
+        {
+                static $cache;
+                if (!$cache)
+                {
+                        $cache = array();
+                }
+
+                $ipath = (string) $ipath;
+
+                if (isset($cache[$ipath]))
+                {
+                        $this->ipath = $cache[$ipath][(int) ($this->scheme !== null)];
+                }
+                else
+                {
+                        $valid = $this->replace_invalid_with_pct_encoding($ipath, '!$&\'()*+,;=@:/');
+                        $removed = $this->remove_dot_segments($valid);
+
+                        $cache[$ipath] = array($valid, $removed);
+                        $this->ipath =  ($this->scheme !== null) ? $removed : $valid;
+                }
+
+                $this->scheme_normalization();
+                return true;
+        }
+
+        /**
+         * Set the iquery.
+         *
+         * @param string $iquery
+         * @return bool
+         */
+        public function set_query($iquery)
+        {
+                if ($iquery === null)
+                {
+                        $this->iquery = null;
+                }
+                else
+                {
+                        $this->iquery = $this->replace_invalid_with_pct_encoding($iquery, '!$&\'()*+,;=:@/?', true);
+                        $this->scheme_normalization();
+                }
+                return true;
+        }
+
+        /**
+         * Set the ifragment.
+         *
+         * @param string $ifragment
+         * @return bool
+         */
+        public function set_fragment($ifragment)
+        {
+                if ($ifragment === null)
+                {
+                        $this->ifragment = null;
+                }
+                else
+                {
+                        $this->ifragment = $this->replace_invalid_with_pct_encoding($ifragment, '!$&\'()*+,;=:@/?');
+                        $this->scheme_normalization();
+                }
+                return true;
+        }
+
+        /**
+         * Convert an IRI to a URI (or parts thereof)
+         *
+         * @return string
+         */
+        public function to_uri($string)
+        {
+                static $non_ascii;
+                if (!$non_ascii)
+                {
+                        $non_ascii = implode('', range("\x80", "\xFF"));
+                }
+
+                $position = 0;
+                $strlen = strlen($string);
+                while (($position += strcspn($string, $non_ascii, $position)) < $strlen)
+                {
+                        $string = substr_replace($string, sprintf('%%%02X', ord($string[$position])), $position, 1);
+                        $position += 3;
+                        $strlen += 2;
+                }
+
+                return $string;
+        }
+
+        /**
+         * Get the complete IRI
+         *
+         * @return string
+         */
+        public function get_iri()
+        {
+                if (!$this->is_valid())
+                {
+                        return false;
+                }
+
+                $iri = '';
+                if ($this->scheme !== null)
+                {
+                        $iri .= $this->scheme . ':';
+                }
+                if (($iauthority = $this->get_iauthority()) !== null)
+                {
+                        $iri .= '//' . $iauthority;
+                }
+                if ($this->ipath !== '')
+                {
+                        $iri .= $this->ipath;
+                }
+                elseif (!empty($this->normalization[$this->scheme]['ipath']) && $iauthority !== null && $iauthority !== '')
+                {
+                        $iri .= $this->normalization[$this->scheme]['ipath'];
+                }
+                if ($this->iquery !== null)
+                {
+                        $iri .= '?' . $this->iquery;
+                }
+                if ($this->ifragment !== null)
+                {
+                        $iri .= '#' . $this->ifragment;
+                }
+
+                return $iri;
+        }
+
+        /**
+         * Get the complete URI
+         *
+         * @return string
+         */
+        public function get_uri()
+        {
+                return $this->to_uri($this->get_iri());
+        }
+
+        /**
+         * Get the complete iauthority
+         *
+         * @return string
+         */
+        protected function get_iauthority()
+        {
+                if ($this->iuserinfo !== null || $this->ihost !== null || $this->port !== null)
+                {
+                        $iauthority = '';
+                        if ($this->iuserinfo !== null)
+                        {
+                                $iauthority .= $this->iuserinfo . '@';
+                        }
+                        if ($this->ihost !== null)
+                        {
+                                $iauthority .= $this->ihost;
+                        }
+                        if ($this->port !== null)
+                        {
+                                $iauthority .= ':' . $this->port;
+                        }
+                        return $iauthority;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the complete authority
+         *
+         * @return string
+         */
+        protected function get_authority()
+        {
+                $iauthority = $this->get_iauthority();
+                if (is_string($iauthority))
+                        return $this->to_uri($iauthority);
+                else
+                        return $iauthority;
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Item.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Item.php
new file mode 100644
index 00000000..a77574b3
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Item.php
@@ -0,0 +1,2964 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Manages all item-related data
+ *
+ * Used by {@see SimplePie::get_item()} and {@see SimplePie::get_items()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_item_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Item
+{
+        /**
+         * Parent feed
+         *
+         * @access private
+         * @var SimplePie
+         */
+        var $feed;
+
+        /**
+         * Raw data
+         *
+         * @access private
+         * @var array
+         */
+        var $data = array();
+
+        /**
+         * Registry object
+         *
+         * @see set_registry
+         * @var SimplePie_Registry
+         */
+        protected $registry;
+
+        /**
+         * Create a new item object
+         *
+         * This is usually used by {@see SimplePie::get_items} and
+         * {@see SimplePie::get_item}. Avoid creating this manually.
+         *
+         * @param SimplePie $feed Parent feed
+         * @param array $data Raw data
+         */
+        public function __construct($feed, $data)
+        {
+                $this->feed = $feed;
+                $this->data = $data;
+        }
+
+        /**
+         * Set the registry handler
+         *
+         * This is usually used by {@see SimplePie_Registry::create}
+         *
+         * @since 1.3
+         * @param SimplePie_Registry $registry
+         */
+        public function set_registry(SimplePie_Registry $registry)
+        {
+                $this->registry = $registry;
+        }
+
+        /**
+         * Get a string representation of the item
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                return md5(serialize($this->data));
+        }
+
+        /**
+         * Remove items that link back to this before destroying this object
+         */
+        public function __destruct()
+        {
+                if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode'))
+                {
+                        unset($this->feed);
+                }
+        }
+
+        /**
+         * Get data for an item-level element
+         *
+         * This method allows you to get access to ANY element/attribute that is a
+         * sub-element of the item/entry tag.
+         *
+         * See {@see SimplePie::get_feed_tags()} for a description of the return value
+         *
+         * @since 1.0
+         * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
+         * @param string $namespace The URL of the XML namespace of the elements you're trying to access
+         * @param string $tag Tag name
+         * @return array
+         */
+        public function get_item_tags($namespace, $tag)
+        {
+                if (isset($this->data['child'][$namespace][$tag]))
+                {
+                        return $this->data['child'][$namespace][$tag];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the base URL value from the parent feed
+         *
+         * Uses `<xml:base>`
+         *
+         * @param array $element
+         * @return string
+         */
+        public function get_base($element = array())
+        {
+                return $this->feed->get_base($element);
+        }
+
+        /**
+         * Sanitize feed data
+         *
+         * @access private
+         * @see SimplePie::sanitize()
+         * @param string $data Data to sanitize
+         * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants
+         * @param string $base Base URL to resolve URLs against
+         * @return string Sanitized data
+         */
+        public function sanitize($data, $type, $base = '')
+        {
+                return $this->feed->sanitize($data, $type, $base);
+        }
+
+        /**
+         * Get the parent feed
+         *
+         * Note: this may not work as you think for multifeeds!
+         *
+         * @link http://simplepie.org/faq/typical_multifeed_gotchas#missing_data_from_feed
+         * @since 1.0
+         * @return SimplePie
+         */
+        public function get_feed()
+        {
+                return $this->feed;
+        }
+
+        /**
+         * Get the unique identifier for the item
+         *
+         * This is usually used when writing code to check for new items in a feed.
+         *
+         * Uses `<atom:id>`, `<guid>`, `<dc:identifier>` or the `about` attribute
+         * for RDF. If none of these are supplied (or `$hash` is true), creates an
+         * MD5 hash based on the permalink and title. If either of those are not
+         * supplied, creates a hash based on the full feed data.
+         *
+         * @since Beta 2
+         * @param boolean $hash Should we force using a hash instead of the supplied ID?
+         * @return string
+         */
+        public function get_id($hash = false)
+        {
+                if (!$hash)
+                {
+                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'id'))
+                        {
+                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'id'))
+                        {
+                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
+                        {
+                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'identifier'))
+                        {
+                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'identifier'))
+                        {
+                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif (isset($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about']))
+                        {
+                                return $this->sanitize($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif (($return = $this->get_permalink()) !== null)
+                        {
+                                return $return;
+                        }
+                        elseif (($return = $this->get_title()) !== null)
+                        {
+                                return $return;
+                        }
+                }
+                if ($this->get_permalink() !== null || $this->get_title() !== null)
+                {
+                        return md5($this->get_permalink() . $this->get_title());
+                }
+                else
+                {
+                        return md5(serialize($this->data));
+                }
+        }
+
+        /**
+         * Get the title of the item
+         *
+         * Uses `<atom:title>`, `<title>` or `<dc:title>`
+         *
+         * @since Beta 2 (previously called `get_item_title` since 0.8)
+         * @return string|null
+         */
+        public function get_title()
+        {
+                if (!isset($this->data['title']))
+                {
+                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
+                        {
+                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        else
+                        {
+                                $this->data['title'] = null;
+                        }
+                }
+                return $this->data['title'];
+        }
+
+        /**
+         * Get the content for the item
+         *
+         * Prefers summaries over full content , but will return full content if a
+         * summary does not exist.
+         *
+         * To prefer full content instead, use {@see get_content}
+         *
+         * Uses `<atom:summary>`, `<description>`, `<dc:description>` or
+         * `<itunes:subtitle>`
+         *
+         * @since 0.8
+         * @param boolean $description_only Should we avoid falling back to the content?
+         * @return string|null
+         */
+        public function get_description($description_only = false)
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'summary'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'summary'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
+                }
+
+                elseif (!$description_only)
+                {
+                        return $this->get_content(true);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the content for the item
+         *
+         * Prefers full content over summaries, but will return a summary if full
+         * content does not exist.
+         *
+         * To prefer summaries instead, use {@see get_description}
+         *
+         * Uses `<atom:content>` or `<content:encoded>` (RSS 1.0 Content Module)
+         *
+         * @since 1.0
+         * @param boolean $content_only Should we avoid falling back to the description?
+         * @return string|null
+         */
+        public function get_content($content_only = false)
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'content'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_content_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'content'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT, 'encoded'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif (!$content_only)
+                {
+                        return $this->get_description(true);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a category for the item
+         *
+         * @since Beta 3 (previously called `get_categories()` since Beta 2)
+         * @param int $key The category that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Category|null
+         */
+        public function get_category($key = 0)
+        {
+                $categories = $this->get_categories();
+                if (isset($categories[$key]))
+                {
+                        return $categories[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all categories for the item
+         *
+         * Uses `<atom:category>`, `<category>` or `<dc:subject>`
+         *
+         * @since Beta 3
+         * @return array|null List of {@see SimplePie_Category} objects
+         */
+        public function get_categories()
+        {
+                $categories = array();
+
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category)
+                {
+                        $term = null;
+                        $scheme = null;
+                        $label = null;
+                        if (isset($category['attribs']['']['term']))
+                        {
+                                $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['scheme']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['label']))
+                        {
+                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category)
+                {
+                        // This is really the label, but keep this as the term also for BC.
+                        // Label will also work on retrieving because that falls back to term.
+                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        if (isset($category['attribs']['']['domain']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        else
+                        {
+                                $scheme = null;
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, null));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($categories))
+                {
+                        return array_unique($categories);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get an author for the item
+         *
+         * @since Beta 2
+         * @param int $key The author that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Author|null
+         */
+        public function get_author($key = 0)
+        {
+                $authors = $this->get_authors();
+                if (isset($authors[$key]))
+                {
+                        return $authors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a contributor for the item
+         *
+         * @since 1.1
+         * @param int $key The contrbutor that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Author|null
+         */
+        public function get_contributor($key = 0)
+        {
+                $contributors = $this->get_contributors();
+                if (isset($contributors[$key]))
+                {
+                        return $contributors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all contributors for the item
+         *
+         * Uses `<atom:contributor>`
+         *
+         * @since 1.1
+         * @return array|null List of {@see SimplePie_Author} objects
+         */
+        public function get_contributors()
+        {
+                $contributors = array();
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+
+                if (!empty($contributors))
+                {
+                        return array_unique($contributors);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all authors for the item
+         *
+         * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>`
+         *
+         * @since Beta 2
+         * @return array|null List of {@see SimplePie_Author} objects
+         */
+        public function get_authors()
+        {
+                $authors = array();
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+                if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'author'))
+                {
+                        $authors[] = $this->registry->create('Author', array(null, null, $this->sanitize($author[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($authors))
+                {
+                        return array_unique($authors);
+                }
+                elseif (($source = $this->get_source()) && ($authors = $source->get_authors()))
+                {
+                        return $authors;
+                }
+                elseif ($authors = $this->feed->get_authors())
+                {
+                        return $authors;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the copyright info for the item
+         *
+         * Uses `<atom:rights>` or `<dc:rights>`
+         *
+         * @since 1.1
+         * @return string
+         */
+        public function get_copyright()
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the posting date/time for the item
+         *
+         * Uses `<atom:published>`, `<atom:updated>`, `<atom:issued>`,
+         * `<atom:modified>`, `<pubDate>` or `<dc:date>`
+         *
+         * Note: obeys PHP's timezone setting. To get a UTC date/time, use
+         * {@see get_gmdate}
+         *
+         * @since Beta 2 (previously called `get_item_date` since 0.8)
+         *
+         * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
+         * @return int|string|null
+         */
+        public function get_date($date_format = 'j F Y, g:i a')
+        {
+                if (!isset($this->data['date']))
+                {
+                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'published'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'issued'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'created'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'modified'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'pubDate'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'date'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'date'))
+                        {
+                                $this->data['date']['raw'] = $return[0]['data'];
+                        }
+
+                        if (!empty($this->data['date']['raw']))
+                        {
+                                $parser = $this->registry->call('Parse_Date', 'get');
+                                $this->data['date']['parsed'] = $parser->parse($this->data['date']['raw']);
+                        }
+                        else
+                        {
+                                $this->data['date'] = null;
+                        }
+                }
+                if ($this->data['date'])
+                {
+                        $date_format = (string) $date_format;
+                        switch ($date_format)
+                        {
+                                case '':
+                                        return $this->sanitize($this->data['date']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
+
+                                case 'U':
+                                        return $this->data['date']['parsed'];
+
+                                default:
+                                        return date($date_format, $this->data['date']['parsed']);
+                        }
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the update date/time for the item
+         *
+         * Uses `<atom:updated>`
+         *
+         * Note: obeys PHP's timezone setting. To get a UTC date/time, use
+         * {@see get_gmdate}
+         *
+         * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
+         * @return int|string|null
+         */
+        public function get_updated_date($date_format = 'j F Y, g:i a')
+        {
+                if (!isset($this->data['updated']))
+                {
+                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
+                        {
+                                $this->data['updated']['raw'] = $return[0]['data'];
+                        }
+
+                        if (!empty($this->data['updated']['raw']))
+                        {
+                                $parser = $this->registry->call('Parse_Date', 'get');
+                                $this->data['updated']['parsed'] = $parser->parse($this->data['date']['raw']);
+                        }
+                        else
+                        {
+                                $this->data['updated'] = null;
+                        }
+                }
+                if ($this->data['updated'])
+                {
+                        $date_format = (string) $date_format;
+                        switch ($date_format)
+                        {
+                                case '':
+                                        return $this->sanitize($this->data['updated']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
+
+                                case 'U':
+                                        return $this->data['updated']['parsed'];
+
+                                default:
+                                        return date($date_format, $this->data['updated']['parsed']);
+                        }
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the localized posting date/time for the item
+         *
+         * Returns the date formatted in the localized language. To display in
+         * languages other than the server's default, you need to change the locale
+         * with {@link http://php.net/setlocale setlocale()}. The available
+         * localizations depend on which ones are installed on your web server.
+         *
+         * @since 1.0
+         *
+         * @param string $date_format Supports any PHP date format from {@see http://php.net/strftime} (empty for the raw data)
+         * @return int|string|null
+         */
+        public function get_local_date($date_format = '%c')
+        {
+                if (!$date_format)
+                {
+                        return $this->sanitize($this->get_date(''), SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (($date = $this->get_date('U')) !== null && $date !== false)
+                {
+                        return strftime($date_format, $date);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the posting date/time for the item (UTC time)
+         *
+         * @see get_date
+         * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
+         * @return int|string|null
+         */
+        public function get_gmdate($date_format = 'j F Y, g:i a')
+        {
+                $date = $this->get_date('U');
+                if ($date === null)
+                {
+                        return null;
+                }
+
+                return gmdate($date_format, $date);
+        }
+
+        /**
+         * Get the update date/time for the item (UTC time)
+         *
+         * @see get_updated_date
+         * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
+         * @return int|string|null
+         */
+        public function get_updated_gmdate($date_format = 'j F Y, g:i a')
+        {
+                $date = $this->get_updated_date('U');
+                if ($date === null)
+                {
+                        return null;
+                }
+
+                return gmdate($date_format, $date);
+        }
+
+        /**
+         * Get the permalink for the item
+         *
+         * Returns the first link available with a relationship of "alternate".
+         * Identical to {@see get_link()} with key 0
+         *
+         * @see get_link
+         * @since 0.8
+         * @return string|null Permalink URL
+         */
+        public function get_permalink()
+        {
+                $link = $this->get_link();
+                $enclosure = $this->get_enclosure(0);
+                if ($link !== null)
+                {
+                        return $link;
+                }
+                elseif ($enclosure !== null)
+                {
+                        return $enclosure->get_link();
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get a single link for the item
+         *
+         * @since Beta 3
+         * @param int $key The link that you want to return.  Remember that arrays begin with 0, not 1
+         * @param string $rel The relationship of the link to return
+         * @return string|null Link URL
+         */
+        public function get_link($key = 0, $rel = 'alternate')
+        {
+                $links = $this->get_links($rel);
+                if ($links[$key] !== null)
+                {
+                        return $links[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all links for the item
+         *
+         * Uses `<atom:link>`, `<link>` or `<guid>`
+         *
+         * @since Beta 2
+         * @param string $rel The relationship of links to return
+         * @return array|null Links found for the item (strings)
+         */
+        public function get_links($rel = 'alternate')
+        {
+                if (!isset($this->data['links']))
+                {
+                        $this->data['links'] = array();
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
+                        {
+                                if (isset($link['attribs']['']['href']))
+                                {
+                                        $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                        $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+
+                                }
+                        }
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
+                        {
+                                if (isset($link['attribs']['']['href']))
+                                {
+                                        $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                        $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+                                }
+                        }
+                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
+                        {
+                                if (!isset($links[0]['attribs']['']['isPermaLink']) || strtolower(trim($links[0]['attribs']['']['isPermaLink'])) === 'true')
+                                {
+                                        $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                                }
+                        }
+
+                        $keys = array_keys($this->data['links']);
+                        foreach ($keys as $key)
+                        {
+                                if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key)))
+                                {
+                                        if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]))
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]);
+                                                $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key];
+                                        }
+                                        else
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key];
+                                        }
+                                }
+                                elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY)
+                                {
+                                        $this->data['links'][substr($key, 41)] =& $this->data['links'][$key];
+                                }
+                                $this->data['links'][$key] = array_unique($this->data['links'][$key]);
+                        }
+                }
+                if (isset($this->data['links'][$rel]))
+                {
+                        return $this->data['links'][$rel];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get an enclosure from the item
+         *
+         * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
+         *
+         * @since Beta 2
+         * @todo Add ability to prefer one type of content over another (in a media group).
+         * @param int $key The enclosure that you want to return.  Remember that arrays begin with 0, not 1
+         * @return SimplePie_Enclosure|null
+         */
+        public function get_enclosure($key = 0, $prefer = null)
+        {
+                $enclosures = $this->get_enclosures();
+                if (isset($enclosures[$key]))
+                {
+                        return $enclosures[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get all available enclosures (podcasts, etc.)
+         *
+         * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
+         *
+         * At this point, we're pretty much assuming that all enclosures for an item
+         * are the same content.  Anything else is too complicated to
+         * properly support.
+         *
+         * @since Beta 2
+         * @todo Add support for end-user defined sorting of enclosures by type/handler (so we can prefer the faster-loading FLV over MP4).
+         * @todo If an element exists at a level, but it's value is empty, we should fall back to the value from the parent (if it exists).
+         * @return array|null List of SimplePie_Enclosure items
+         */
+        public function get_enclosures()
+        {
+                if (!isset($this->data['enclosures']))
+                {
+                        $this->data['enclosures'] = array();
+
+                        // Elements
+                        $captions_parent = null;
+                        $categories_parent = null;
+                        $copyrights_parent = null;
+                        $credits_parent = null;
+                        $description_parent = null;
+                        $duration_parent = null;
+                        $hashes_parent = null;
+                        $keywords_parent = null;
+                        $player_parent = null;
+                        $ratings_parent = null;
+                        $restrictions_parent = null;
+                        $thumbnails_parent = null;
+                        $title_parent = null;
+
+                        // Let's do the channel and item-level ones first, and just re-use them if we need to.
+                        $parent = $this->get_feed();
+
+                        // CAPTIONS
+                        if ($captions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
+                        {
+                                foreach ($captions as $caption)
+                                {
+                                        $caption_type = null;
+                                        $caption_lang = null;
+                                        $caption_startTime = null;
+                                        $caption_endTime = null;
+                                        $caption_text = null;
+                                        if (isset($caption['attribs']['']['type']))
+                                        {
+                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['lang']))
+                                        {
+                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['start']))
+                                        {
+                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['end']))
+                                        {
+                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['data']))
+                                        {
+                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
+                                }
+                        }
+                        elseif ($captions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
+                        {
+                                foreach ($captions as $caption)
+                                {
+                                        $caption_type = null;
+                                        $caption_lang = null;
+                                        $caption_startTime = null;
+                                        $caption_endTime = null;
+                                        $caption_text = null;
+                                        if (isset($caption['attribs']['']['type']))
+                                        {
+                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['lang']))
+                                        {
+                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['start']))
+                                        {
+                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['attribs']['']['end']))
+                                        {
+                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($caption['data']))
+                                        {
+                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
+                                }
+                        }
+                        if (is_array($captions_parent))
+                        {
+                                $captions_parent = array_values(array_unique($captions_parent));
+                        }
+
+                        // CATEGORIES
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
+                        {
+                                $term = null;
+                                $scheme = null;
+                                $label = null;
+                                if (isset($category['data']))
+                                {
+                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                if (isset($category['attribs']['']['scheme']))
+                                {
+                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                else
+                                {
+                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
+                                }
+                                if (isset($category['attribs']['']['label']))
+                                {
+                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
+                        }
+                        foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
+                        {
+                                $term = null;
+                                $scheme = null;
+                                $label = null;
+                                if (isset($category['data']))
+                                {
+                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                if (isset($category['attribs']['']['scheme']))
+                                {
+                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                else
+                                {
+                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
+                                }
+                                if (isset($category['attribs']['']['label']))
+                                {
+                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
+                        }
+                        foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'category') as $category)
+                        {
+                                $term = null;
+                                $scheme = 'http://www.itunes.com/dtds/podcast-1.0.dtd';
+                                $label = null;
+                                if (isset($category['attribs']['']['text']))
+                                {
+                                        $label = $this->sanitize($category['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
+
+                                if (isset($category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category']))
+                                {
+                                        foreach ((array) $category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category'] as $subcategory)
+                                        {
+                                                if (isset($subcategory['attribs']['']['text']))
+                                                {
+                                                        $label = $this->sanitize($subcategory['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
+                                        }
+                                }
+                        }
+                        if (is_array($categories_parent))
+                        {
+                                $categories_parent = array_values(array_unique($categories_parent));
+                        }
+
+                        // COPYRIGHT
+                        if ($copyright = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
+                        {
+                                $copyright_url = null;
+                                $copyright_label = null;
+                                if (isset($copyright[0]['attribs']['']['url']))
+                                {
+                                        $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                if (isset($copyright[0]['data']))
+                                {
+                                        $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
+                        }
+                        elseif ($copyright = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
+                        {
+                                $copyright_url = null;
+                                $copyright_label = null;
+                                if (isset($copyright[0]['attribs']['']['url']))
+                                {
+                                        $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                if (isset($copyright[0]['data']))
+                                {
+                                        $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                                $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
+                        }
+
+                        // CREDITS
+                        if ($credits = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
+                        {
+                                foreach ($credits as $credit)
+                                {
+                                        $credit_role = null;
+                                        $credit_scheme = null;
+                                        $credit_name = null;
+                                        if (isset($credit['attribs']['']['role']))
+                                        {
+                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($credit['attribs']['']['scheme']))
+                                        {
+                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $credit_scheme = 'urn:ebu';
+                                        }
+                                        if (isset($credit['data']))
+                                        {
+                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
+                                }
+                        }
+                        elseif ($credits = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
+                        {
+                                foreach ($credits as $credit)
+                                {
+                                        $credit_role = null;
+                                        $credit_scheme = null;
+                                        $credit_name = null;
+                                        if (isset($credit['attribs']['']['role']))
+                                        {
+                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($credit['attribs']['']['scheme']))
+                                        {
+                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $credit_scheme = 'urn:ebu';
+                                        }
+                                        if (isset($credit['data']))
+                                        {
+                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
+                                }
+                        }
+                        if (is_array($credits_parent))
+                        {
+                                $credits_parent = array_values(array_unique($credits_parent));
+                        }
+
+                        // DESCRIPTION
+                        if ($description_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
+                        {
+                                if (isset($description_parent[0]['data']))
+                                {
+                                        $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                        }
+                        elseif ($description_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
+                        {
+                                if (isset($description_parent[0]['data']))
+                                {
+                                        $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                        }
+
+                        // DURATION
+                        if ($duration_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'duration'))
+                        {
+                                $seconds = null;
+                                $minutes = null;
+                                $hours = null;
+                                if (isset($duration_parent[0]['data']))
+                                {
+                                        $temp = explode(':', $this->sanitize($duration_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                        if (sizeof($temp) > 0)
+                                        {
+                                                $seconds = (int) array_pop($temp);
+                                        }
+                                        if (sizeof($temp) > 0)
+                                        {
+                                                $minutes = (int) array_pop($temp);
+                                                $seconds += $minutes * 60;
+                                        }
+                                        if (sizeof($temp) > 0)
+                                        {
+                                                $hours = (int) array_pop($temp);
+                                                $seconds += $hours * 3600;
+                                        }
+                                        unset($temp);
+                                        $duration_parent = $seconds;
+                                }
+                        }
+
+                        // HASHES
+                        if ($hashes_iterator = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
+                        {
+                                foreach ($hashes_iterator as $hash)
+                                {
+                                        $value = null;
+                                        $algo = null;
+                                        if (isset($hash['data']))
+                                        {
+                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($hash['attribs']['']['algo']))
+                                        {
+                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $algo = 'md5';
+                                        }
+                                        $hashes_parent[] = $algo.':'.$value;
+                                }
+                        }
+                        elseif ($hashes_iterator = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
+                        {
+                                foreach ($hashes_iterator as $hash)
+                                {
+                                        $value = null;
+                                        $algo = null;
+                                        if (isset($hash['data']))
+                                        {
+                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($hash['attribs']['']['algo']))
+                                        {
+                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $algo = 'md5';
+                                        }
+                                        $hashes_parent[] = $algo.':'.$value;
+                                }
+                        }
+                        if (is_array($hashes_parent))
+                        {
+                                $hashes_parent = array_values(array_unique($hashes_parent));
+                        }
+
+                        // KEYWORDS
+                        if ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
+                        {
+                                if (isset($keywords[0]['data']))
+                                {
+                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                        foreach ($temp as $word)
+                                        {
+                                                $keywords_parent[] = trim($word);
+                                        }
+                                }
+                                unset($temp);
+                        }
+                        elseif ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
+                        {
+                                if (isset($keywords[0]['data']))
+                                {
+                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                        foreach ($temp as $word)
+                                        {
+                                                $keywords_parent[] = trim($word);
+                                        }
+                                }
+                                unset($temp);
+                        }
+                        elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
+                        {
+                                if (isset($keywords[0]['data']))
+                                {
+                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                        foreach ($temp as $word)
+                                        {
+                                                $keywords_parent[] = trim($word);
+                                        }
+                                }
+                                unset($temp);
+                        }
+                        elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
+                        {
+                                if (isset($keywords[0]['data']))
+                                {
+                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                        foreach ($temp as $word)
+                                        {
+                                                $keywords_parent[] = trim($word);
+                                        }
+                                }
+                                unset($temp);
+                        }
+                        if (is_array($keywords_parent))
+                        {
+                                $keywords_parent = array_values(array_unique($keywords_parent));
+                        }
+
+                        // PLAYER
+                        if ($player_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
+                        {
+                                if (isset($player_parent[0]['attribs']['']['url']))
+                                {
+                                        $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                }
+                        }
+                        elseif ($player_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
+                        {
+                                if (isset($player_parent[0]['attribs']['']['url']))
+                                {
+                                        $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                }
+                        }
+
+                        // RATINGS
+                        if ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
+                        {
+                                foreach ($ratings as $rating)
+                                {
+                                        $rating_scheme = null;
+                                        $rating_value = null;
+                                        if (isset($rating['attribs']['']['scheme']))
+                                        {
+                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $rating_scheme = 'urn:simple';
+                                        }
+                                        if (isset($rating['data']))
+                                        {
+                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                }
+                        }
+                        elseif ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
+                        {
+                                foreach ($ratings as $rating)
+                                {
+                                        $rating_scheme = 'urn:itunes';
+                                        $rating_value = null;
+                                        if (isset($rating['data']))
+                                        {
+                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                }
+                        }
+                        elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
+                        {
+                                foreach ($ratings as $rating)
+                                {
+                                        $rating_scheme = null;
+                                        $rating_value = null;
+                                        if (isset($rating['attribs']['']['scheme']))
+                                        {
+                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        else
+                                        {
+                                                $rating_scheme = 'urn:simple';
+                                        }
+                                        if (isset($rating['data']))
+                                        {
+                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                }
+                        }
+                        elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
+                        {
+                                foreach ($ratings as $rating)
+                                {
+                                        $rating_scheme = 'urn:itunes';
+                                        $rating_value = null;
+                                        if (isset($rating['data']))
+                                        {
+                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                }
+                        }
+                        if (is_array($ratings_parent))
+                        {
+                                $ratings_parent = array_values(array_unique($ratings_parent));
+                        }
+
+                        // RESTRICTIONS
+                        if ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
+                        {
+                                foreach ($restrictions as $restriction)
+                                {
+                                        $restriction_relationship = null;
+                                        $restriction_type = null;
+                                        $restriction_value = null;
+                                        if (isset($restriction['attribs']['']['relationship']))
+                                        {
+                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($restriction['attribs']['']['type']))
+                                        {
+                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($restriction['data']))
+                                        {
+                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                }
+                        }
+                        elseif ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
+                        {
+                                foreach ($restrictions as $restriction)
+                                {
+                                        $restriction_relationship = 'allow';
+                                        $restriction_type = null;
+                                        $restriction_value = 'itunes';
+                                        if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
+                                        {
+                                                $restriction_relationship = 'deny';
+                                        }
+                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                }
+                        }
+                        elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
+                        {
+                                foreach ($restrictions as $restriction)
+                                {
+                                        $restriction_relationship = null;
+                                        $restriction_type = null;
+                                        $restriction_value = null;
+                                        if (isset($restriction['attribs']['']['relationship']))
+                                        {
+                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($restriction['attribs']['']['type']))
+                                        {
+                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($restriction['data']))
+                                        {
+                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                }
+                        }
+                        elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
+                        {
+                                foreach ($restrictions as $restriction)
+                                {
+                                        $restriction_relationship = 'allow';
+                                        $restriction_type = null;
+                                        $restriction_value = 'itunes';
+                                        if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
+                                        {
+                                                $restriction_relationship = 'deny';
+                                        }
+                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                }
+                        }
+                        if (is_array($restrictions_parent))
+                        {
+                                $restrictions_parent = array_values(array_unique($restrictions_parent));
+                        }
+                        else
+                        {
+                                $restrictions_parent = array(new SimplePie_Restriction('allow', null, 'default'));
+                        }
+
+                        // THUMBNAILS
+                        if ($thumbnails = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
+                        {
+                                foreach ($thumbnails as $thumbnail)
+                                {
+                                        if (isset($thumbnail['attribs']['']['url']))
+                                        {
+                                                $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                        }
+                                }
+                        }
+                        elseif ($thumbnails = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
+                        {
+                                foreach ($thumbnails as $thumbnail)
+                                {
+                                        if (isset($thumbnail['attribs']['']['url']))
+                                        {
+                                                $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                        }
+                                }
+                        }
+
+                        // TITLES
+                        if ($title_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
+                        {
+                                if (isset($title_parent[0]['data']))
+                                {
+                                        $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                        }
+                        elseif ($title_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
+                        {
+                                if (isset($title_parent[0]['data']))
+                                {
+                                        $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                }
+                        }
+
+                        // Clear the memory
+                        unset($parent);
+
+                        // Attributes
+                        $bitrate = null;
+                        $channels = null;
+                        $duration = null;
+                        $expression = null;
+                        $framerate = null;
+                        $height = null;
+                        $javascript = null;
+                        $lang = null;
+                        $length = null;
+                        $medium = null;
+                        $samplingrate = null;
+                        $type = null;
+                        $url = null;
+                        $width = null;
+
+                        // Elements
+                        $captions = null;
+                        $categories = null;
+                        $copyrights = null;
+                        $credits = null;
+                        $description = null;
+                        $hashes = null;
+                        $keywords = null;
+                        $player = null;
+                        $ratings = null;
+                        $restrictions = null;
+                        $thumbnails = null;
+                        $title = null;
+
+                        // If we have media:group tags, loop through them.
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group') as $group)
+                        {
+                                if(isset($group['child']) && isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
+                                {
+                                        // If we have media:content tags, loop through them.
+                                        foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
+                                        {
+                                                if (isset($content['attribs']['']['url']))
+                                                {
+                                                        // Attributes
+                                                        $bitrate = null;
+                                                        $channels = null;
+                                                        $duration = null;
+                                                        $expression = null;
+                                                        $framerate = null;
+                                                        $height = null;
+                                                        $javascript = null;
+                                                        $lang = null;
+                                                        $length = null;
+                                                        $medium = null;
+                                                        $samplingrate = null;
+                                                        $type = null;
+                                                        $url = null;
+                                                        $width = null;
+
+                                                        // Elements
+                                                        $captions = null;
+                                                        $categories = null;
+                                                        $copyrights = null;
+                                                        $credits = null;
+                                                        $description = null;
+                                                        $hashes = null;
+                                                        $keywords = null;
+                                                        $player = null;
+                                                        $ratings = null;
+                                                        $restrictions = null;
+                                                        $thumbnails = null;
+                                                        $title = null;
+
+                                                        // Start checking the attributes of media:content
+                                                        if (isset($content['attribs']['']['bitrate']))
+                                                        {
+                                                                $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['channels']))
+                                                        {
+                                                                $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['duration']))
+                                                        {
+                                                                $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        else
+                                                        {
+                                                                $duration = $duration_parent;
+                                                        }
+                                                        if (isset($content['attribs']['']['expression']))
+                                                        {
+                                                                $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['framerate']))
+                                                        {
+                                                                $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['height']))
+                                                        {
+                                                                $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['lang']))
+                                                        {
+                                                                $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['fileSize']))
+                                                        {
+                                                                $length = ceil($content['attribs']['']['fileSize']);
+                                                        }
+                                                        if (isset($content['attribs']['']['medium']))
+                                                        {
+                                                                $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['samplingrate']))
+                                                        {
+                                                                $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['type']))
+                                                        {
+                                                                $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['attribs']['']['width']))
+                                                        {
+                                                                $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+
+                                                        // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
+
+                                                        // CAPTIONS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
+                                                                {
+                                                                        $caption_type = null;
+                                                                        $caption_lang = null;
+                                                                        $caption_startTime = null;
+                                                                        $caption_endTime = null;
+                                                                        $caption_text = null;
+                                                                        if (isset($caption['attribs']['']['type']))
+                                                                        {
+                                                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['lang']))
+                                                                        {
+                                                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['start']))
+                                                                        {
+                                                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['end']))
+                                                                        {
+                                                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['data']))
+                                                                        {
+                                                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
+                                                                }
+                                                                if (is_array($captions))
+                                                                {
+                                                                        $captions = array_values(array_unique($captions));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
+                                                                {
+                                                                        $caption_type = null;
+                                                                        $caption_lang = null;
+                                                                        $caption_startTime = null;
+                                                                        $caption_endTime = null;
+                                                                        $caption_text = null;
+                                                                        if (isset($caption['attribs']['']['type']))
+                                                                        {
+                                                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['lang']))
+                                                                        {
+                                                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['start']))
+                                                                        {
+                                                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['attribs']['']['end']))
+                                                                        {
+                                                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($caption['data']))
+                                                                        {
+                                                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
+                                                                }
+                                                                if (is_array($captions))
+                                                                {
+                                                                        $captions = array_values(array_unique($captions));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $captions = $captions_parent;
+                                                        }
+
+                                                        // CATEGORIES
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
+                                                        {
+                                                                foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
+                                                                {
+                                                                        $term = null;
+                                                                        $scheme = null;
+                                                                        $label = null;
+                                                                        if (isset($category['data']))
+                                                                        {
+                                                                                $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($category['attribs']['']['scheme']))
+                                                                        {
+                                                                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $scheme = 'http://search.yahoo.com/mrss/category_schema';
+                                                                        }
+                                                                        if (isset($category['attribs']['']['label']))
+                                                                        {
+                                                                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                                                                }
+                                                        }
+                                                        if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
+                                                        {
+                                                                foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
+                                                                {
+                                                                        $term = null;
+                                                                        $scheme = null;
+                                                                        $label = null;
+                                                                        if (isset($category['data']))
+                                                                        {
+                                                                                $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($category['attribs']['']['scheme']))
+                                                                        {
+                                                                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $scheme = 'http://search.yahoo.com/mrss/category_schema';
+                                                                        }
+                                                                        if (isset($category['attribs']['']['label']))
+                                                                        {
+                                                                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                                                                }
+                                                        }
+                                                        if (is_array($categories) && is_array($categories_parent))
+                                                        {
+                                                                $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
+                                                        }
+                                                        elseif (is_array($categories))
+                                                        {
+                                                                $categories = array_values(array_unique($categories));
+                                                        }
+                                                        elseif (is_array($categories_parent))
+                                                        {
+                                                                $categories = array_values(array_unique($categories_parent));
+                                                        }
+
+                                                        // COPYRIGHTS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
+                                                        {
+                                                                $copyright_url = null;
+                                                                $copyright_label = null;
+                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
+                                                                {
+                                                                        $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
+                                                                {
+                                                                        $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
+                                                        {
+                                                                $copyright_url = null;
+                                                                $copyright_label = null;
+                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
+                                                                {
+                                                                        $copyright_url = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
+                                                                {
+                                                                        $copyright_label = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
+                                                        }
+                                                        else
+                                                        {
+                                                                $copyrights = $copyrights_parent;
+                                                        }
+
+                                                        // CREDITS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
+                                                                {
+                                                                        $credit_role = null;
+                                                                        $credit_scheme = null;
+                                                                        $credit_name = null;
+                                                                        if (isset($credit['attribs']['']['role']))
+                                                                        {
+                                                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($credit['attribs']['']['scheme']))
+                                                                        {
+                                                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $credit_scheme = 'urn:ebu';
+                                                                        }
+                                                                        if (isset($credit['data']))
+                                                                        {
+                                                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
+                                                                }
+                                                                if (is_array($credits))
+                                                                {
+                                                                        $credits = array_values(array_unique($credits));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
+                                                                {
+                                                                        $credit_role = null;
+                                                                        $credit_scheme = null;
+                                                                        $credit_name = null;
+                                                                        if (isset($credit['attribs']['']['role']))
+                                                                        {
+                                                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($credit['attribs']['']['scheme']))
+                                                                        {
+                                                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $credit_scheme = 'urn:ebu';
+                                                                        }
+                                                                        if (isset($credit['data']))
+                                                                        {
+                                                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
+                                                                }
+                                                                if (is_array($credits))
+                                                                {
+                                                                        $credits = array_values(array_unique($credits));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $credits = $credits_parent;
+                                                        }
+
+                                                        // DESCRIPTION
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
+                                                        {
+                                                                $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
+                                                        {
+                                                                $description = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        else
+                                                        {
+                                                                $description = $description_parent;
+                                                        }
+
+                                                        // HASHES
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
+                                                                {
+                                                                        $value = null;
+                                                                        $algo = null;
+                                                                        if (isset($hash['data']))
+                                                                        {
+                                                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($hash['attribs']['']['algo']))
+                                                                        {
+                                                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $algo = 'md5';
+                                                                        }
+                                                                        $hashes[] = $algo.':'.$value;
+                                                                }
+                                                                if (is_array($hashes))
+                                                                {
+                                                                        $hashes = array_values(array_unique($hashes));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
+                                                                {
+                                                                        $value = null;
+                                                                        $algo = null;
+                                                                        if (isset($hash['data']))
+                                                                        {
+                                                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($hash['attribs']['']['algo']))
+                                                                        {
+                                                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $algo = 'md5';
+                                                                        }
+                                                                        $hashes[] = $algo.':'.$value;
+                                                                }
+                                                                if (is_array($hashes))
+                                                                {
+                                                                        $hashes = array_values(array_unique($hashes));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $hashes = $hashes_parent;
+                                                        }
+
+                                                        // KEYWORDS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
+                                                        {
+                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
+                                                                {
+                                                                        $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                                                        foreach ($temp as $word)
+                                                                        {
+                                                                                $keywords[] = trim($word);
+                                                                        }
+                                                                        unset($temp);
+                                                                }
+                                                                if (is_array($keywords))
+                                                                {
+                                                                        $keywords = array_values(array_unique($keywords));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
+                                                        {
+                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
+                                                                {
+                                                                        $temp = explode(',', $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                                                        foreach ($temp as $word)
+                                                                        {
+                                                                                $keywords[] = trim($word);
+                                                                        }
+                                                                        unset($temp);
+                                                                }
+                                                                if (is_array($keywords))
+                                                                {
+                                                                        $keywords = array_values(array_unique($keywords));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $keywords = $keywords_parent;
+                                                        }
+
+                                                        // PLAYER
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
+                                                        {
+                                                                $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
+                                                        {
+                                                                $player = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                        }
+                                                        else
+                                                        {
+                                                                $player = $player_parent;
+                                                        }
+
+                                                        // RATINGS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
+                                                                {
+                                                                        $rating_scheme = null;
+                                                                        $rating_value = null;
+                                                                        if (isset($rating['attribs']['']['scheme']))
+                                                                        {
+                                                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $rating_scheme = 'urn:simple';
+                                                                        }
+                                                                        if (isset($rating['data']))
+                                                                        {
+                                                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                                                }
+                                                                if (is_array($ratings))
+                                                                {
+                                                                        $ratings = array_values(array_unique($ratings));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
+                                                                {
+                                                                        $rating_scheme = null;
+                                                                        $rating_value = null;
+                                                                        if (isset($rating['attribs']['']['scheme']))
+                                                                        {
+                                                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                $rating_scheme = 'urn:simple';
+                                                                        }
+                                                                        if (isset($rating['data']))
+                                                                        {
+                                                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                                                }
+                                                                if (is_array($ratings))
+                                                                {
+                                                                        $ratings = array_values(array_unique($ratings));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $ratings = $ratings_parent;
+                                                        }
+
+                                                        // RESTRICTIONS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
+                                                                {
+                                                                        $restriction_relationship = null;
+                                                                        $restriction_type = null;
+                                                                        $restriction_value = null;
+                                                                        if (isset($restriction['attribs']['']['relationship']))
+                                                                        {
+                                                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($restriction['attribs']['']['type']))
+                                                                        {
+                                                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($restriction['data']))
+                                                                        {
+                                                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                                                }
+                                                                if (is_array($restrictions))
+                                                                {
+                                                                        $restrictions = array_values(array_unique($restrictions));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
+                                                                {
+                                                                        $restriction_relationship = null;
+                                                                        $restriction_type = null;
+                                                                        $restriction_value = null;
+                                                                        if (isset($restriction['attribs']['']['relationship']))
+                                                                        {
+                                                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($restriction['attribs']['']['type']))
+                                                                        {
+                                                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        if (isset($restriction['data']))
+                                                                        {
+                                                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                        }
+                                                                        $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                                                }
+                                                                if (is_array($restrictions))
+                                                                {
+                                                                        $restrictions = array_values(array_unique($restrictions));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $restrictions = $restrictions_parent;
+                                                        }
+
+                                                        // THUMBNAILS
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
+                                                        {
+                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
+                                                                {
+                                                                        $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                                }
+                                                                if (is_array($thumbnails))
+                                                                {
+                                                                        $thumbnails = array_values(array_unique($thumbnails));
+                                                                }
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
+                                                        {
+                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
+                                                                {
+                                                                        $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                                }
+                                                                if (is_array($thumbnails))
+                                                                {
+                                                                        $thumbnails = array_values(array_unique($thumbnails));
+                                                                }
+                                                        }
+                                                        else
+                                                        {
+                                                                $thumbnails = $thumbnails_parent;
+                                                        }
+
+                                                        // TITLES
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
+                                                        {
+                                                                $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
+                                                        {
+                                                                $title = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        else
+                                                        {
+                                                                $title = $title_parent;
+                                                        }
+
+                                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
+                                                }
+                                        }
+                                }
+                        }
+
+                        // If we have standalone media:content tags, loop through them.
+                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
+                        {
+                                foreach ((array) $this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
+                                {
+                                        if (isset($content['attribs']['']['url']) || isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
+                                        {
+                                                // Attributes
+                                                $bitrate = null;
+                                                $channels = null;
+                                                $duration = null;
+                                                $expression = null;
+                                                $framerate = null;
+                                                $height = null;
+                                                $javascript = null;
+                                                $lang = null;
+                                                $length = null;
+                                                $medium = null;
+                                                $samplingrate = null;
+                                                $type = null;
+                                                $url = null;
+                                                $width = null;
+
+                                                // Elements
+                                                $captions = null;
+                                                $categories = null;
+                                                $copyrights = null;
+                                                $credits = null;
+                                                $description = null;
+                                                $hashes = null;
+                                                $keywords = null;
+                                                $player = null;
+                                                $ratings = null;
+                                                $restrictions = null;
+                                                $thumbnails = null;
+                                                $title = null;
+
+                                                // Start checking the attributes of media:content
+                                                if (isset($content['attribs']['']['bitrate']))
+                                                {
+                                                        $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['channels']))
+                                                {
+                                                        $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['duration']))
+                                                {
+                                                        $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                else
+                                                {
+                                                        $duration = $duration_parent;
+                                                }
+                                                if (isset($content['attribs']['']['expression']))
+                                                {
+                                                        $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['framerate']))
+                                                {
+                                                        $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['height']))
+                                                {
+                                                        $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['lang']))
+                                                {
+                                                        $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['fileSize']))
+                                                {
+                                                        $length = ceil($content['attribs']['']['fileSize']);
+                                                }
+                                                if (isset($content['attribs']['']['medium']))
+                                                {
+                                                        $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['samplingrate']))
+                                                {
+                                                        $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['type']))
+                                                {
+                                                        $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['width']))
+                                                {
+                                                        $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                if (isset($content['attribs']['']['url']))
+                                                {
+                                                        $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                }
+                                                // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
+
+                                                // CAPTIONS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
+                                                        {
+                                                                $caption_type = null;
+                                                                $caption_lang = null;
+                                                                $caption_startTime = null;
+                                                                $caption_endTime = null;
+                                                                $caption_text = null;
+                                                                if (isset($caption['attribs']['']['type']))
+                                                                {
+                                                                        $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($caption['attribs']['']['lang']))
+                                                                {
+                                                                        $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($caption['attribs']['']['start']))
+                                                                {
+                                                                        $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($caption['attribs']['']['end']))
+                                                                {
+                                                                        $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($caption['data']))
+                                                                {
+                                                                        $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
+                                                        }
+                                                        if (is_array($captions))
+                                                        {
+                                                                $captions = array_values(array_unique($captions));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $captions = $captions_parent;
+                                                }
+
+                                                // CATEGORIES
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
+                                                {
+                                                        foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
+                                                        {
+                                                                $term = null;
+                                                                $scheme = null;
+                                                                $label = null;
+                                                                if (isset($category['data']))
+                                                                {
+                                                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($category['attribs']['']['scheme']))
+                                                                {
+                                                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                else
+                                                                {
+                                                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
+                                                                }
+                                                                if (isset($category['attribs']['']['label']))
+                                                                {
+                                                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                                                        }
+                                                }
+                                                if (is_array($categories) && is_array($categories_parent))
+                                                {
+                                                        $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
+                                                }
+                                                elseif (is_array($categories))
+                                                {
+                                                        $categories = array_values(array_unique($categories));
+                                                }
+                                                elseif (is_array($categories_parent))
+                                                {
+                                                        $categories = array_values(array_unique($categories_parent));
+                                                }
+                                                else
+                                                {
+                                                        $categories = null;
+                                                }
+
+                                                // COPYRIGHTS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
+                                                {
+                                                        $copyright_url = null;
+                                                        $copyright_label = null;
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
+                                                        {
+                                                                $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
+                                                        {
+                                                                $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                        }
+                                                        $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
+                                                }
+                                                else
+                                                {
+                                                        $copyrights = $copyrights_parent;
+                                                }
+
+                                                // CREDITS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
+                                                        {
+                                                                $credit_role = null;
+                                                                $credit_scheme = null;
+                                                                $credit_name = null;
+                                                                if (isset($credit['attribs']['']['role']))
+                                                                {
+                                                                        $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($credit['attribs']['']['scheme']))
+                                                                {
+                                                                        $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                else
+                                                                {
+                                                                        $credit_scheme = 'urn:ebu';
+                                                                }
+                                                                if (isset($credit['data']))
+                                                                {
+                                                                        $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
+                                                        }
+                                                        if (is_array($credits))
+                                                        {
+                                                                $credits = array_values(array_unique($credits));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $credits = $credits_parent;
+                                                }
+
+                                                // DESCRIPTION
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
+                                                {
+                                                        $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                else
+                                                {
+                                                        $description = $description_parent;
+                                                }
+
+                                                // HASHES
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
+                                                        {
+                                                                $value = null;
+                                                                $algo = null;
+                                                                if (isset($hash['data']))
+                                                                {
+                                                                        $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($hash['attribs']['']['algo']))
+                                                                {
+                                                                        $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                else
+                                                                {
+                                                                        $algo = 'md5';
+                                                                }
+                                                                $hashes[] = $algo.':'.$value;
+                                                        }
+                                                        if (is_array($hashes))
+                                                        {
+                                                                $hashes = array_values(array_unique($hashes));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $hashes = $hashes_parent;
+                                                }
+
+                                                // KEYWORDS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
+                                                {
+                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
+                                                        {
+                                                                $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
+                                                                foreach ($temp as $word)
+                                                                {
+                                                                        $keywords[] = trim($word);
+                                                                }
+                                                                unset($temp);
+                                                        }
+                                                        if (is_array($keywords))
+                                                        {
+                                                                $keywords = array_values(array_unique($keywords));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $keywords = $keywords_parent;
+                                                }
+
+                                                // PLAYER
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
+                                                {
+                                                        $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                }
+                                                else
+                                                {
+                                                        $player = $player_parent;
+                                                }
+
+                                                // RATINGS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
+                                                        {
+                                                                $rating_scheme = null;
+                                                                $rating_value = null;
+                                                                if (isset($rating['attribs']['']['scheme']))
+                                                                {
+                                                                        $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                else
+                                                                {
+                                                                        $rating_scheme = 'urn:simple';
+                                                                }
+                                                                if (isset($rating['data']))
+                                                                {
+                                                                        $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
+                                                        }
+                                                        if (is_array($ratings))
+                                                        {
+                                                                $ratings = array_values(array_unique($ratings));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $ratings = $ratings_parent;
+                                                }
+
+                                                // RESTRICTIONS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
+                                                        {
+                                                                $restriction_relationship = null;
+                                                                $restriction_type = null;
+                                                                $restriction_value = null;
+                                                                if (isset($restriction['attribs']['']['relationship']))
+                                                                {
+                                                                        $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($restriction['attribs']['']['type']))
+                                                                {
+                                                                        $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                if (isset($restriction['data']))
+                                                                {
+                                                                        $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                                }
+                                                                $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
+                                                        }
+                                                        if (is_array($restrictions))
+                                                        {
+                                                                $restrictions = array_values(array_unique($restrictions));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $restrictions = $restrictions_parent;
+                                                }
+
+                                                // THUMBNAILS
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
+                                                {
+                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
+                                                        {
+                                                                $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
+                                                        }
+                                                        if (is_array($thumbnails))
+                                                        {
+                                                                $thumbnails = array_values(array_unique($thumbnails));
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        $thumbnails = $thumbnails_parent;
+                                                }
+
+                                                // TITLES
+                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
+                                                {
+                                                        $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                                }
+                                                else
+                                                {
+                                                        $title = $title_parent;
+                                                }
+
+                                                $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
+                                        }
+                                }
+                        }
+
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
+                        {
+                                if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
+                                {
+                                        // Attributes
+                                        $bitrate = null;
+                                        $channels = null;
+                                        $duration = null;
+                                        $expression = null;
+                                        $framerate = null;
+                                        $height = null;
+                                        $javascript = null;
+                                        $lang = null;
+                                        $length = null;
+                                        $medium = null;
+                                        $samplingrate = null;
+                                        $type = null;
+                                        $url = null;
+                                        $width = null;
+
+                                        $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+                                        if (isset($link['attribs']['']['type']))
+                                        {
+                                                $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($link['attribs']['']['length']))
+                                        {
+                                                $length = ceil($link['attribs']['']['length']);
+                                        }
+
+                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
+                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
+                                }
+                        }
+
+                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
+                        {
+                                if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
+                                {
+                                        // Attributes
+                                        $bitrate = null;
+                                        $channels = null;
+                                        $duration = null;
+                                        $expression = null;
+                                        $framerate = null;
+                                        $height = null;
+                                        $javascript = null;
+                                        $lang = null;
+                                        $length = null;
+                                        $medium = null;
+                                        $samplingrate = null;
+                                        $type = null;
+                                        $url = null;
+                                        $width = null;
+
+                                        $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+                                        if (isset($link['attribs']['']['type']))
+                                        {
+                                                $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($link['attribs']['']['length']))
+                                        {
+                                                $length = ceil($link['attribs']['']['length']);
+                                        }
+
+                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
+                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
+                                }
+                        }
+
+                        if ($enclosure = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'enclosure'))
+                        {
+                                if (isset($enclosure[0]['attribs']['']['url']))
+                                {
+                                        // Attributes
+                                        $bitrate = null;
+                                        $channels = null;
+                                        $duration = null;
+                                        $expression = null;
+                                        $framerate = null;
+                                        $height = null;
+                                        $javascript = null;
+                                        $lang = null;
+                                        $length = null;
+                                        $medium = null;
+                                        $samplingrate = null;
+                                        $type = null;
+                                        $url = null;
+                                        $width = null;
+
+                                        $url = $this->sanitize($enclosure[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($enclosure[0]));
+                                        if (isset($enclosure[0]['attribs']['']['type']))
+                                        {
+                                                $type = $this->sanitize($enclosure[0]['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
+                                        }
+                                        if (isset($enclosure[0]['attribs']['']['length']))
+                                        {
+                                                $length = ceil($enclosure[0]['attribs']['']['length']);
+                                        }
+
+                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
+                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
+                                }
+                        }
+
+                        if (sizeof($this->data['enclosures']) === 0 && ($url || $type || $length || $bitrate || $captions_parent || $categories_parent || $channels || $copyrights_parent || $credits_parent || $description_parent || $duration_parent || $expression || $framerate || $hashes_parent || $height || $keywords_parent || $lang || $medium || $player_parent || $ratings_parent || $restrictions_parent || $samplingrate || $thumbnails_parent || $title_parent || $width))
+                        {
+                                // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
+                                $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
+                        }
+
+                        $this->data['enclosures'] = array_values(array_unique($this->data['enclosures']));
+                }
+                if (!empty($this->data['enclosures']))
+                {
+                        return $this->data['enclosures'];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the latitude coordinates for the item
+         *
+         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
+         *
+         * Uses `<geo:lat>` or `<georss:point>`
+         *
+         * @since 1.0
+         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
+         * @link http://www.georss.org/ GeoRSS
+         * @return string|null
+         */
+        public function get_latitude()
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[1];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the longitude coordinates for the item
+         *
+         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
+         *
+         * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>`
+         *
+         * @since 1.0
+         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
+         * @link http://www.georss.org/ GeoRSS
+         * @return string|null
+         */
+        public function get_longitude()
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[2];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the `<atom:source>` for the item
+         *
+         * @since 1.1
+         * @return SimplePie_Source|null
+         */
+        public function get_source()
+        {
+                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'source'))
+                {
+                        return $this->registry->create('Source', array($this, $return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Locator.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Locator.php
new file mode 100644
index 00000000..57e910c2
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Locator.php
@@ -0,0 +1,372 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Used for feed auto-discovery
+ *
+ *
+ * This class can be overloaded with {@see SimplePie::set_locator_class()}
+ *
+ * @package SimplePie
+ */
+class SimplePie_Locator
+{
+        var $useragent;
+        var $timeout;
+        var $file;
+        var $local = array();
+        var $elsewhere = array();
+        var $cached_entities = array();
+        var $http_base;
+        var $base;
+        var $base_location = 0;
+        var $checked_feeds = 0;
+        var $max_checked_feeds = 10;
+        protected $registry;
+
+        public function __construct(SimplePie_File $file, $timeout = 10, $useragent = null, $max_checked_feeds = 10)
+        {
+                $this->file = $file;
+                $this->useragent = $useragent;
+                $this->timeout = $timeout;
+                $this->max_checked_feeds = $max_checked_feeds;
+
+                if (class_exists('DOMDocument'))
+                {
+                        $this->dom = new DOMDocument();
+
+                        set_error_handler(array('SimplePie_Misc', 'silence_errors'));
+                        $this->dom->loadHTML($this->file->body);
+                        restore_error_handler();
+                }
+                else
+                {
+                        $this->dom = null;
+                }
+        }
+
+        public function set_registry(SimplePie_Registry $registry)
+        {
+                $this->registry = $registry;
+        }
+
+        public function find($type = SIMPLEPIE_LOCATOR_ALL, &$working)
+        {
+                if ($this->is_feed($this->file))
+                {
+                        return $this->file;
+                }
+
+                if ($this->file->method & SIMPLEPIE_FILE_SOURCE_REMOTE)
+                {
+                        $sniffer = $this->registry->create('Content_Type_Sniffer', array($this->file));
+                        if ($sniffer->get_type() !== 'text/html')
+                        {
+                                return null;
+                        }
+                }
+
+                if ($type & ~SIMPLEPIE_LOCATOR_NONE)
+                {
+                        $this->get_base();
+                }
+
+                if ($type & SIMPLEPIE_LOCATOR_AUTODISCOVERY && $working = $this->autodiscovery())
+                {
+                        return $working[0];
+                }
+
+                if ($type & (SIMPLEPIE_LOCATOR_LOCAL_EXTENSION | SIMPLEPIE_LOCATOR_LOCAL_BODY | SIMPLEPIE_LOCATOR_REMOTE_EXTENSION | SIMPLEPIE_LOCATOR_REMOTE_BODY) && $this->get_links())
+                {
+                        if ($type & SIMPLEPIE_LOCATOR_LOCAL_EXTENSION && $working = $this->extension($this->local))
+                        {
+                                return $working;
+                        }
+
+                        if ($type & SIMPLEPIE_LOCATOR_LOCAL_BODY && $working = $this->body($this->local))
+                        {
+                                return $working;
+                        }
+
+                        if ($type & SIMPLEPIE_LOCATOR_REMOTE_EXTENSION && $working = $this->extension($this->elsewhere))
+                        {
+                                return $working;
+                        }
+
+                        if ($type & SIMPLEPIE_LOCATOR_REMOTE_BODY && $working = $this->body($this->elsewhere))
+                        {
+                                return $working;
+                        }
+                }
+                return null;
+        }
+
+        public function is_feed($file)
+        {
+                if ($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE)
+                {
+                        $sniffer = $this->registry->create('Content_Type_Sniffer', array($file));
+                        $sniffed = $sniffer->get_type();
+                        if (in_array($sniffed, array('application/rss+xml', 'application/rdf+xml', 'text/rdf', 'application/atom+xml', 'text/xml', 'application/xml')))
+                        {
+                                return true;
+                        }
+                        else
+                        {
+                                return false;
+                        }
+                }
+                elseif ($file->method & SIMPLEPIE_FILE_SOURCE_LOCAL)
+                {
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        public function get_base()
+        {
+                if ($this->dom === null)
+                {
+                        throw new SimplePie_Exception('DOMDocument not found, unable to use locator');
+                }
+                $this->http_base = $this->file->url;
+                $this->base = $this->http_base;
+                $elements = $this->dom->getElementsByTagName('base');
+                foreach ($elements as $element)
+                {
+                        if ($element->hasAttribute('href'))
+                        {
+                                $base = $this->registry->call('Misc', 'absolutize_url', array(trim($element->getAttribute('href')), $this->http_base));
+                                if ($base === false)
+                                {
+                                        continue;
+                                }
+                                $this->base = $base;
+                                $this->base_location = method_exists($element, 'getLineNo') ? $element->getLineNo() : 0;
+                                break;
+                        }
+                }
+        }
+
+        public function autodiscovery()
+        {
+                $done = array();
+                $feeds = array();
+                $feeds = array_merge($feeds, $this->search_elements_by_tag('link', $done, $feeds));
+                $feeds = array_merge($feeds, $this->search_elements_by_tag('a', $done, $feeds));
+                $feeds = array_merge($feeds, $this->search_elements_by_tag('area', $done, $feeds));
+
+                if (!empty($feeds))
+                {
+                        return array_values($feeds);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        protected function search_elements_by_tag($name, &$done, $feeds)
+        {
+                if ($this->dom === null)
+                {
+                        throw new SimplePie_Exception('DOMDocument not found, unable to use locator');
+                }
+
+                $links = $this->dom->getElementsByTagName($name);
+                foreach ($links as $link)
+                {
+                        if ($this->checked_feeds === $this->max_checked_feeds)
+                        {
+                                break;
+                        }
+                        if ($link->hasAttribute('href') && $link->hasAttribute('rel'))
+                        {
+                                $rel = array_unique($this->registry->call('Misc', 'space_seperated_tokens', array(strtolower($link->getAttribute('rel')))));
+                                $line = method_exists($link, 'getLineNo') ? $link->getLineNo() : 1;
+
+                                if ($this->base_location < $line)
+                                {
+                                        $href = $this->registry->call('Misc', 'absolutize_url', array(trim($link->getAttribute('href')), $this->base));
+                                }
+                                else
+                                {
+                                        $href = $this->registry->call('Misc', 'absolutize_url', array(trim($link->getAttribute('href')), $this->http_base));
+                                }
+                                if ($href === false)
+                                {
+                                        continue;
+                                }
+
+                                if (!in_array($href, $done) && in_array('feed', $rel) || (in_array('alternate', $rel) && !in_array('stylesheet', $rel) && $link->hasAttribute('type') && in_array(strtolower($this->registry->call('Misc', 'parse_mime', array($link->getAttribute('type')))), array('application/rss+xml', 'application/atom+xml'))) && !isset($feeds[$href]))
+                                {
+                                        $this->checked_feeds++;
+                                        $headers = array(
+                                                'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',
+                                        );
+                                        $feed = $this->registry->create('File', array($href, $this->timeout, 5, $headers, $this->useragent));
+                                        if ($feed->success && ($feed->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($feed->status_code === 200 || $feed->status_code > 206 && $feed->status_code < 300)) && $this->is_feed($feed))
+                                        {
+                                                $feeds[$href] = $feed;
+                                        }
+                                }
+                                $done[] = $href;
+                        }
+                }
+
+                return $feeds;
+        }
+
+        public function get_links()
+        {
+                if ($this->dom === null)
+                {
+                        throw new SimplePie_Exception('DOMDocument not found, unable to use locator');
+                }
+
+                $links = $this->dom->getElementsByTagName('a');
+                foreach ($links as $link)
+                {
+                        if ($link->hasAttribute('href'))
+                        {
+                                $href = trim($link->getAttribute('href'));
+                                $parsed = $this->registry->call('Misc', 'parse_url', array($href));
+                                if ($parsed['scheme'] === '' || preg_match('/^(http(s)|feed)?$/i', $parsed['scheme']))
+                                {
+                                        if ($this->base_location < $link->getLineNo())
+                                        {
+                                                $href = $this->registry->call('Misc', 'absolutize_url', array(trim($link->getAttribute('href')), $this->base));
+                                        }
+                                        else
+                                        {
+                                                $href = $this->registry->call('Misc', 'absolutize_url', array(trim($link->getAttribute('href')), $this->http_base));
+                                        }
+                                        if ($href === false)
+                                        {
+                                                continue;
+                                        }
+
+                                        $current = $this->registry->call('Misc', 'parse_url', array($this->file->url));
+
+                                        if ($parsed['authority'] === '' || $parsed['authority'] === $current['authority'])
+                                        {
+                                                $this->local[] = $href;
+                                        }
+                                        else
+                                        {
+                                                $this->elsewhere[] = $href;
+                                        }
+                                }
+                        }
+                }
+                $this->local = array_unique($this->local);
+                $this->elsewhere = array_unique($this->elsewhere);
+                if (!empty($this->local) || !empty($this->elsewhere))
+                {
+                        return true;
+                }
+                return null;
+        }
+
+        public function extension(&$array)
+        {
+                foreach ($array as $key => $value)
+                {
+                        if ($this->checked_feeds === $this->max_checked_feeds)
+                        {
+                                break;
+                        }
+                        if (in_array(strtolower(strrchr($value, '.')), array('.rss', '.rdf', '.atom', '.xml')))
+                        {
+                                $this->checked_feeds++;
+
+                                $headers = array(
+                                        'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',
+                                );
+                                $feed = $this->registry->create('File', array($value, $this->timeout, 5, $headers, $this->useragent));
+                                if ($feed->success && ($feed->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($feed->status_code === 200 || $feed->status_code > 206 && $feed->status_code < 300)) && $this->is_feed($feed))
+                                {
+                                        return $feed;
+                                }
+                                else
+                                {
+                                        unset($array[$key]);
+                                }
+                        }
+                }
+                return null;
+        }
+
+        public function body(&$array)
+        {
+                foreach ($array as $key => $value)
+                {
+                        if ($this->checked_feeds === $this->max_checked_feeds)
+                        {
+                                break;
+                        }
+                        if (preg_match('/(rss|rdf|atom|xml)/i', $value))
+                        {
+                                $this->checked_feeds++;
+                                $headers = array(
+                                        'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',
+                                );
+                                $feed = $this->registry->create('File', array($value, $this->timeout, 5, null, $this->useragent));
+                                if ($feed->success && ($feed->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($feed->status_code === 200 || $feed->status_code > 206 && $feed->status_code < 300)) && $this->is_feed($feed))
+                                {
+                                        return $feed;
+                                }
+                                else
+                                {
+                                        unset($array[$key]);
+                                }
+                        }
+                }
+                return null;
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Misc.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Misc.php
new file mode 100644
index 00000000..5d7367f6
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Misc.php
@@ -0,0 +1,2247 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Miscellanous utilities
+ *
+ * @package SimplePie
+ */
+class SimplePie_Misc
+{
+        public static function time_hms($seconds)
+        {
+                $time = '';
+
+                $hours = floor($seconds / 3600);
+                $remainder = $seconds % 3600;
+                if ($hours > 0)
+                {
+                        $time .= $hours.':';
+                }
+
+                $minutes = floor($remainder / 60);
+                $seconds = $remainder % 60;
+                if ($minutes < 10 && $hours > 0)
+                {
+                        $minutes = '0' . $minutes;
+                }
+                if ($seconds < 10)
+                {
+                        $seconds = '0' . $seconds;
+                }
+
+                $time .= $minutes.':';
+                $time .= $seconds;
+
+                return $time;
+        }
+
+        public static function absolutize_url($relative, $base)
+        {
+                $iri = SimplePie_IRI::absolutize(new SimplePie_IRI($base), $relative);
+                if ($iri === false)
+                {
+                        return false;
+                }
+                return $iri->get_uri();
+        }
+
+        /**
+         * Get a HTML/XML element from a HTML string
+         *
+         * @deprecated Use DOMDocument instead (parsing HTML with regex is bad!)
+         * @param string $realname Element name (including namespace prefix if applicable)
+         * @param string $string HTML document
+         * @return array
+         */
+        public static function get_element($realname, $string)
+        {
+                $return = array();
+                $name = preg_quote($realname, '/');
+                if (preg_match_all("/<($name)" . SIMPLEPIE_PCRE_HTML_ATTRIBUTE . "(>(.*)<\/$name>|(\/)?>)/siU", $string, $matches, PREG_SET_ORDER | PREG_OFFSET_CAPTURE))
+                {
+                        for ($i = 0, $total_matches = count($matches); $i < $total_matches; $i++)
+                        {
+                                $return[$i]['tag'] = $realname;
+                                $return[$i]['full'] = $matches[$i][0][0];
+                                $return[$i]['offset'] = $matches[$i][0][1];
+                                if (strlen($matches[$i][3][0]) <= 2)
+                                {
+                                        $return[$i]['self_closing'] = true;
+                                }
+                                else
+                                {
+                                        $return[$i]['self_closing'] = false;
+                                        $return[$i]['content'] = $matches[$i][4][0];
+                                }
+                                $return[$i]['attribs'] = array();
+                                if (isset($matches[$i][2][0]) && preg_match_all('/[\x09\x0A\x0B\x0C\x0D\x20]+([^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3D\x3E]*)(?:[\x09\x0A\x0B\x0C\x0D\x20]*=[\x09\x0A\x0B\x0C\x0D\x20]*(?:"([^"]*)"|\'([^\']*)\'|([^\x09\x0A\x0B\x0C\x0D\x20\x22\x27\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x3E]*)?))?/', ' ' . $matches[$i][2][0] . ' ', $attribs, PREG_SET_ORDER))
+                                {
+                                        for ($j = 0, $total_attribs = count($attribs); $j < $total_attribs; $j++)
+                                        {
+                                                if (count($attribs[$j]) === 2)
+                                                {
+                                                        $attribs[$j][2] = $attribs[$j][1];
+                                                }
+                                                $return[$i]['attribs'][strtolower($attribs[$j][1])]['data'] = SimplePie_Misc::entities_decode(end($attribs[$j]), 'UTF-8');
+                                        }
+                                }
+                        }
+                }
+                return $return;
+        }
+
+        public static function element_implode($element)
+        {
+                $full = "<$element[tag]";
+                foreach ($element['attribs'] as $key => $value)
+                {
+                        $key = strtolower($key);
+                        $full .= " $key=\"" . htmlspecialchars($value['data']) . '"';
+                }
+                if ($element['self_closing'])
+                {
+                        $full .= ' />';
+                }
+                else
+                {
+                        $full .= ">$element[content]</$element[tag]>";
+                }
+                return $full;
+        }
+
+        public static function error($message, $level, $file, $line)
+        {
+                if ((ini_get('error_reporting') & $level) > 0)
+                {
+                        switch ($level)
+                        {
+                                case E_USER_ERROR:
+                                        $note = 'PHP Error';
+                                        break;
+                                case E_USER_WARNING:
+                                        $note = 'PHP Warning';
+                                        break;
+                                case E_USER_NOTICE:
+                                        $note = 'PHP Notice';
+                                        break;
+                                default:
+                                        $note = 'Unknown Error';
+                                        break;
+                        }
+
+                        $log_error = true;
+                        if (!function_exists('error_log'))
+                        {
+                                $log_error = false;
+                        }
+
+                        $log_file = @ini_get('error_log');
+                        if (!empty($log_file) && ('syslog' !== $log_file) && !@is_writable($log_file))
+                        {
+                                $log_error = false;
+                        }
+
+                        if ($log_error)
+                        {
+                                @error_log("$note: $message in $file on line $line", 0);
+                        }
+                }
+
+                return $message;
+        }
+
+        public static function fix_protocol($url, $http = 1)
+        {
+                $url = SimplePie_Misc::normalize_url($url);
+                $parsed = SimplePie_Misc::parse_url($url);
+                if ($parsed['scheme'] !== '' && $parsed['scheme'] !== 'http' && $parsed['scheme'] !== 'https')
+                {
+                        return SimplePie_Misc::fix_protocol(SimplePie_Misc::compress_parse_url('http', $parsed['authority'], $parsed['path'], $parsed['query'], $parsed['fragment']), $http);
+                }
+
+                if ($parsed['scheme'] === '' && $parsed['authority'] === '' && !file_exists($url))
+                {
+                        return SimplePie_Misc::fix_protocol(SimplePie_Misc::compress_parse_url('http', $parsed['path'], '', $parsed['query'], $parsed['fragment']), $http);
+                }
+
+                if ($http === 2 && $parsed['scheme'] !== '')
+                {
+                        return "feed:$url";
+                }
+                elseif ($http === 3 && strtolower($parsed['scheme']) === 'http')
+                {
+                        return substr_replace($url, 'podcast', 0, 4);
+                }
+                elseif ($http === 4 && strtolower($parsed['scheme']) === 'http')
+                {
+                        return substr_replace($url, 'itpc', 0, 4);
+                }
+                else
+                {
+                        return $url;
+                }
+        }
+
+        public static function parse_url($url)
+        {
+                $iri = new SimplePie_IRI($url);
+                return array(
+                        'scheme' => (string) $iri->scheme,
+                        'authority' => (string) $iri->authority,
+                        'path' => (string) $iri->path,
+                        'query' => (string) $iri->query,
+                        'fragment' => (string) $iri->fragment
+                );
+        }
+
+        public static function compress_parse_url($scheme = '', $authority = '', $path = '', $query = '', $fragment = '')
+        {
+                $iri = new SimplePie_IRI('');
+                $iri->scheme = $scheme;
+                $iri->authority = $authority;
+                $iri->path = $path;
+                $iri->query = $query;
+                $iri->fragment = $fragment;
+                return $iri->get_uri();
+        }
+
+        public static function normalize_url($url)
+        {
+                $iri = new SimplePie_IRI($url);
+                return $iri->get_uri();
+        }
+
+        public static function percent_encoding_normalization($match)
+        {
+                $integer = hexdec($match[1]);
+                if ($integer >= 0x41 && $integer <= 0x5A || $integer >= 0x61 && $integer <= 0x7A || $integer >= 0x30 && $integer <= 0x39 || $integer === 0x2D || $integer === 0x2E || $integer === 0x5F || $integer === 0x7E)
+                {
+                        return chr($integer);
+                }
+                else
+                {
+                        return strtoupper($match[0]);
+                }
+        }
+
+        /**
+         * Converts a Windows-1252 encoded string to a UTF-8 encoded string
+         *
+         * @static
+         * @param string $string Windows-1252 encoded string
+         * @return string UTF-8 encoded string
+         */
+        public static function windows_1252_to_utf8($string)
+        {
+                static $convert_table = array("\x80" => "\xE2\x82\xAC", "\x81" => "\xEF\xBF\xBD", "\x82" => "\xE2\x80\x9A", "\x83" => "\xC6\x92", "\x84" => "\xE2\x80\x9E", "\x85" => "\xE2\x80\xA6", "\x86" => "\xE2\x80\xA0", "\x87" => "\xE2\x80\xA1", "\x88" => "\xCB\x86", "\x89" => "\xE2\x80\xB0", "\x8A" => "\xC5\xA0", "\x8B" => "\xE2\x80\xB9", "\x8C" => "\xC5\x92", "\x8D" => "\xEF\xBF\xBD", "\x8E" => "\xC5\xBD", "\x8F" => "\xEF\xBF\xBD", "\x90" => "\xEF\xBF\xBD", "\x91" => "\xE2\x80\x98", "\x92" => "\xE2\x80\x99", "\x93" => "\xE2\x80\x9C", "\x94" => "\xE2\x80\x9D", "\x95" => "\xE2\x80\xA2", "\x96" => "\xE2\x80\x93", "\x97" => "\xE2\x80\x94", "\x98" => "\xCB\x9C", "\x99" => "\xE2\x84\xA2", "\x9A" => "\xC5\xA1", "\x9B" => "\xE2\x80\xBA", "\x9C" => "\xC5\x93", "\x9D" => "\xEF\xBF\xBD", "\x9E" => "\xC5\xBE", "\x9F" => "\xC5\xB8", "\xA0" => "\xC2\xA0", "\xA1" => "\xC2\xA1", "\xA2" => "\xC2\xA2", "\xA3" => "\xC2\xA3", "\xA4" => "\xC2\xA4", "\xA5" => "\xC2\xA5", "\xA6" => "\xC2\xA6", "\xA7" => "\xC2\xA7", "\xA8" => "\xC2\xA8", "\xA9" => "\xC2\xA9", "\xAA" => "\xC2\xAA", "\xAB" => "\xC2\xAB", "\xAC" => "\xC2\xAC", "\xAD" => "\xC2\xAD", "\xAE" => "\xC2\xAE", "\xAF" => "\xC2\xAF", "\xB0" => "\xC2\xB0", "\xB1" => "\xC2\xB1", "\xB2" => "\xC2\xB2", "\xB3" => "\xC2\xB3", "\xB4" => "\xC2\xB4", "\xB5" => "\xC2\xB5", "\xB6" => "\xC2\xB6", "\xB7" => "\xC2\xB7", "\xB8" => "\xC2\xB8", "\xB9" => "\xC2\xB9", "\xBA" => "\xC2\xBA", "\xBB" => "\xC2\xBB", "\xBC" => "\xC2\xBC", "\xBD" => "\xC2\xBD", "\xBE" => "\xC2\xBE", "\xBF" => "\xC2\xBF", "\xC0" => "\xC3\x80", "\xC1" => "\xC3\x81", "\xC2" => "\xC3\x82", "\xC3" => "\xC3\x83", "\xC4" => "\xC3\x84", "\xC5" => "\xC3\x85", "\xC6" => "\xC3\x86", "\xC7" => "\xC3\x87", "\xC8" => "\xC3\x88", "\xC9" => "\xC3\x89", "\xCA" => "\xC3\x8A", "\xCB" => "\xC3\x8B", "\xCC" => "\xC3\x8C", "\xCD" => "\xC3\x8D", "\xCE" => "\xC3\x8E", "\xCF" => "\xC3\x8F", "\xD0" => "\xC3\x90", "\xD1" => "\xC3\x91", "\xD2" => "\xC3\x92", "\xD3" => "\xC3\x93", "\xD4" => "\xC3\x94", "\xD5" => "\xC3\x95", "\xD6" => "\xC3\x96", "\xD7" => "\xC3\x97", "\xD8" => "\xC3\x98", "\xD9" => "\xC3\x99", "\xDA" => "\xC3\x9A", "\xDB" => "\xC3\x9B", "\xDC" => "\xC3\x9C", "\xDD" => "\xC3\x9D", "\xDE" => "\xC3\x9E", "\xDF" => "\xC3\x9F", "\xE0" => "\xC3\xA0", "\xE1" => "\xC3\xA1", "\xE2" => "\xC3\xA2", "\xE3" => "\xC3\xA3", "\xE4" => "\xC3\xA4", "\xE5" => "\xC3\xA5", "\xE6" => "\xC3\xA6", "\xE7" => "\xC3\xA7", "\xE8" => "\xC3\xA8", "\xE9" => "\xC3\xA9", "\xEA" => "\xC3\xAA", "\xEB" => "\xC3\xAB", "\xEC" => "\xC3\xAC", "\xED" => "\xC3\xAD", "\xEE" => "\xC3\xAE", "\xEF" => "\xC3\xAF", "\xF0" => "\xC3\xB0", "\xF1" => "\xC3\xB1", "\xF2" => "\xC3\xB2", "\xF3" => "\xC3\xB3", "\xF4" => "\xC3\xB4", "\xF5" => "\xC3\xB5", "\xF6" => "\xC3\xB6", "\xF7" => "\xC3\xB7", "\xF8" => "\xC3\xB8", "\xF9" => "\xC3\xB9", "\xFA" => "\xC3\xBA", "\xFB" => "\xC3\xBB", "\xFC" => "\xC3\xBC", "\xFD" => "\xC3\xBD", "\xFE" => "\xC3\xBE", "\xFF" => "\xC3\xBF");
+
+                return strtr($string, $convert_table);
+        }
+
+        /**
+         * Change a string from one encoding to another
+         *
+         * @param string $data Raw data in $input encoding
+         * @param string $input Encoding of $data
+         * @param string $output Encoding you want
+         * @return string|boolean False if we can't convert it
+         */
+        public static function change_encoding($data, $input, $output)
+        {
+                $input = SimplePie_Misc::encoding($input);
+                $output = SimplePie_Misc::encoding($output);
+
+                // We fail to fail on non US-ASCII bytes
+                if ($input === 'US-ASCII')
+                {
+                        static $non_ascii_octects = '';
+                        if (!$non_ascii_octects)
+                        {
+                                for ($i = 0x80; $i <= 0xFF; $i++)
+                                {
+                                        $non_ascii_octects .= chr($i);
+                                }
+                        }
+                        $data = substr($data, 0, strcspn($data, $non_ascii_octects));
+                }
+
+                // This is first, as behaviour of this is completely predictable
+                if ($input === 'windows-1252' && $output === 'UTF-8')
+                {
+                        return SimplePie_Misc::windows_1252_to_utf8($data);
+                }
+                // This is second, as behaviour of this varies only with PHP version (the middle part of this expression checks the encoding is supported).
+                elseif (function_exists('mb_convert_encoding') && ($return = SimplePie_Misc::change_encoding_mbstring($data, $input, $output)))
+                {
+                        return $return;
+                }
+                // This is last, as behaviour of this varies with OS userland and PHP version
+                elseif (function_exists('iconv') && ($return = SimplePie_Misc::change_encoding_iconv($data, $input, $output)))
+                {
+                        return $return;
+                }
+                // If we can't do anything, just fail
+                else
+                {
+                        return false;
+                }
+        }
+
+        protected static function change_encoding_mbstring($data, $input, $output)
+        {
+                if ($input === 'windows-949')
+                {
+                        $input = 'EUC-KR';
+                }
+                if ($output === 'windows-949')
+                {
+                        $output = 'EUC-KR';
+                }
+                if ($input === 'Windows-31J')
+                {
+                        $input = 'SJIS';
+                }
+                if ($output === 'Windows-31J')
+                {
+                        $output = 'SJIS';
+                }
+
+                // Check that the encoding is supported
+                if (@mb_convert_encoding("\x80", 'UTF-16BE', $input) === "\x00\x80")
+                {
+                        return false;
+                }
+                if (!in_array($input, mb_list_encodings()))
+                {
+                        return false;
+                }
+
+                // Let's do some conversion
+                if ($return = @mb_convert_encoding($data, $output, $input))
+                {
+                        return $return;
+                }
+
+                return false;
+        }
+
+        protected static function change_encoding_iconv($data, $input, $output)
+        {
+                return @iconv($input, $output, $data);
+        }
+
+        /**
+         * Normalize an encoding name
+         *
+         * This is automatically generated by create.php
+         *
+         * To generate it, run `php create.php` on the command line, and copy the
+         * output to replace this function.
+         *
+         * @param string $charset Character set to standardise
+         * @return string Standardised name
+         */
+        public static function encoding($charset)
+        {
+                // Normalization from UTS #22
+                switch (strtolower(preg_replace('/(?:[^a-zA-Z0-9]+|([^0-9])0+)/', '\1', $charset)))
+                {
+                        case 'adobestandardencoding':
+                        case 'csadobestandardencoding':
+                                return 'Adobe-Standard-Encoding';
+
+                        case 'adobesymbolencoding':
+                        case 'cshppsmath':
+                                return 'Adobe-Symbol-Encoding';
+
+                        case 'ami1251':
+                        case 'amiga1251':
+                                return 'Amiga-1251';
+
+                        case 'ansix31101983':
+                        case 'csat5001983':
+                        case 'csiso99naplps':
+                        case 'isoir99':
+                        case 'naplps':
+                                return 'ANSI_X3.110-1983';
+
+                        case 'arabic7':
+                        case 'asmo449':
+                        case 'csiso89asmo449':
+                        case 'iso9036':
+                        case 'isoir89':
+                                return 'ASMO_449';
+
+                        case 'big5':
+                        case 'csbig5':
+                                return 'Big5';
+
+                        case 'big5hkscs':
+                                return 'Big5-HKSCS';
+
+                        case 'bocu1':
+                        case 'csbocu1':
+                                return 'BOCU-1';
+
+                        case 'brf':
+                        case 'csbrf':
+                                return 'BRF';
+
+                        case 'bs4730':
+                        case 'csiso4unitedkingdom':
+                        case 'gb':
+                        case 'iso646gb':
+                        case 'isoir4':
+                        case 'uk':
+                                return 'BS_4730';
+
+                        case 'bsviewdata':
+                        case 'csiso47bsviewdata':
+                        case 'isoir47':
+                                return 'BS_viewdata';
+
+                        case 'cesu8':
+                        case 'cscesu8':
+                                return 'CESU-8';
+
+                        case 'ca':
+                        case 'csa71':
+                        case 'csaz243419851':
+                        case 'csiso121canadian1':
+                        case 'iso646ca':
+                        case 'isoir121':
+                                return 'CSA_Z243.4-1985-1';
+
+                        case 'csa72':
+                        case 'csaz243419852':
+                        case 'csiso122canadian2':
+                        case 'iso646ca2':
+                        case 'isoir122':
+                                return 'CSA_Z243.4-1985-2';
+
+                        case 'csaz24341985gr':
+                        case 'csiso123csaz24341985gr':
+                        case 'isoir123':
+                                return 'CSA_Z243.4-1985-gr';
+
+                        case 'csiso139csn369103':
+                        case 'csn369103':
+                        case 'isoir139':
+                                return 'CSN_369103';
+
+                        case 'csdecmcs':
+                        case 'dec':
+                        case 'decmcs':
+                                return 'DEC-MCS';
+
+                        case 'csiso21german':
+                        case 'de':
+                        case 'din66003':
+                        case 'iso646de':
+                        case 'isoir21':
+                                return 'DIN_66003';
+
+                        case 'csdkus':
+                        case 'dkus':
+                                return 'dk-us';
+
+                        case 'csiso646danish':
+                        case 'dk':
+                        case 'ds2089':
+                        case 'iso646dk':
+                                return 'DS_2089';
+
+                        case 'csibmebcdicatde':
+                        case 'ebcdicatde':
+                                return 'EBCDIC-AT-DE';
+
+                        case 'csebcdicatdea':
+                        case 'ebcdicatdea':
+                                return 'EBCDIC-AT-DE-A';
+
+                        case 'csebcdiccafr':
+                        case 'ebcdiccafr':
+                                return 'EBCDIC-CA-FR';
+
+                        case 'csebcdicdkno':
+                        case 'ebcdicdkno':
+                                return 'EBCDIC-DK-NO';
+
+                        case 'csebcdicdknoa':
+                        case 'ebcdicdknoa':
+                                return 'EBCDIC-DK-NO-A';
+
+                        case 'csebcdices':
+                        case 'ebcdices':
+                                return 'EBCDIC-ES';
+
+                        case 'csebcdicesa':
+                        case 'ebcdicesa':
+                                return 'EBCDIC-ES-A';
+
+                        case 'csebcdicess':
+                        case 'ebcdicess':
+                                return 'EBCDIC-ES-S';
+
+                        case 'csebcdicfise':
+                        case 'ebcdicfise':
+                                return 'EBCDIC-FI-SE';
+
+                        case 'csebcdicfisea':
+                        case 'ebcdicfisea':
+                                return 'EBCDIC-FI-SE-A';
+
+                        case 'csebcdicfr':
+                        case 'ebcdicfr':
+                                return 'EBCDIC-FR';
+
+                        case 'csebcdicit':
+                        case 'ebcdicit':
+                                return 'EBCDIC-IT';
+
+                        case 'csebcdicpt':
+                        case 'ebcdicpt':
+                                return 'EBCDIC-PT';
+
+                        case 'csebcdicuk':
+                        case 'ebcdicuk':
+                                return 'EBCDIC-UK';
+
+                        case 'csebcdicus':
+                        case 'ebcdicus':
+                                return 'EBCDIC-US';
+
+                        case 'csiso111ecmacyrillic':
+                        case 'ecmacyrillic':
+                        case 'isoir111':
+                        case 'koi8e':
+                                return 'ECMA-cyrillic';
+
+                        case 'csiso17spanish':
+                        case 'es':
+                        case 'iso646es':
+                        case 'isoir17':
+                                return 'ES';
+
+                        case 'csiso85spanish2':
+                        case 'es2':
+                        case 'iso646es2':
+                        case 'isoir85':
+                                return 'ES2';
+
+                        case 'cseucpkdfmtjapanese':
+                        case 'eucjp':
+                        case 'extendedunixcodepackedformatforjapanese':
+                                return 'EUC-JP';
+
+                        case 'cseucfixwidjapanese':
+                        case 'extendedunixcodefixedwidthforjapanese':
+                                return 'Extended_UNIX_Code_Fixed_Width_for_Japanese';
+
+                        case 'gb18030':
+                                return 'GB18030';
+
+                        case 'chinese':
+                        case 'cp936':
+                        case 'csgb2312':
+                        case 'csiso58gb231280':
+                        case 'gb2312':
+                        case 'gb231280':
+                        case 'gbk':
+                        case 'isoir58':
+                        case 'ms936':
+                        case 'windows936':
+                                return 'GBK';
+
+                        case 'cn':
+                        case 'csiso57gb1988':
+                        case 'gb198880':
+                        case 'iso646cn':
+                        case 'isoir57':
+                                return 'GB_1988-80';
+
+                        case 'csiso153gost1976874':
+                        case 'gost1976874':
+                        case 'isoir153':
+                        case 'stsev35888':
+                                return 'GOST_19768-74';
+
+                        case 'csiso150':
+                        case 'csiso150greekccitt':
+                        case 'greekccitt':
+                        case 'isoir150':
+                                return 'greek-ccitt';
+
+                        case 'csiso88greek7':
+                        case 'greek7':
+                        case 'isoir88':
+                                return 'greek7';
+
+                        case 'csiso18greek7old':
+                        case 'greek7old':
+                        case 'isoir18':
+                                return 'greek7-old';
+
+                        case 'cshpdesktop':
+                        case 'hpdesktop':
+                                return 'HP-DeskTop';
+
+                        case 'cshplegal':
+                        case 'hplegal':
+                                return 'HP-Legal';
+
+                        case 'cshpmath8':
+                        case 'hpmath8':
+                                return 'HP-Math8';
+
+                        case 'cshppifont':
+                        case 'hppifont':
+                                return 'HP-Pi-font';
+
+                        case 'cshproman8':
+                        case 'hproman8':
+                        case 'r8':
+                        case 'roman8':
+                                return 'hp-roman8';
+
+                        case 'hzgb2312':
+                                return 'HZ-GB-2312';
+
+                        case 'csibmsymbols':
+                        case 'ibmsymbols':
+                                return 'IBM-Symbols';
+
+                        case 'csibmthai':
+                        case 'ibmthai':
+                                return 'IBM-Thai';
+
+                        case 'cp37':
+                        case 'csibm37':
+                        case 'ebcdiccpca':
+                        case 'ebcdiccpnl':
+                        case 'ebcdiccpus':
+                        case 'ebcdiccpwt':
+                        case 'ibm37':
+                                return 'IBM037';
+
+                        case 'cp38':
+                        case 'csibm38':
+                        case 'ebcdicint':
+                        case 'ibm38':
+                                return 'IBM038';
+
+                        case 'cp273':
+                        case 'csibm273':
+                        case 'ibm273':
+                                return 'IBM273';
+
+                        case 'cp274':
+                        case 'csibm274':
+                        case 'ebcdicbe':
+                        case 'ibm274':
+                                return 'IBM274';
+
+                        case 'cp275':
+                        case 'csibm275':
+                        case 'ebcdicbr':
+                        case 'ibm275':
+                                return 'IBM275';
+
+                        case 'csibm277':
+                        case 'ebcdiccpdk':
+                        case 'ebcdiccpno':
+                        case 'ibm277':
+                                return 'IBM277';
+
+                        case 'cp278':
+                        case 'csibm278':
+                        case 'ebcdiccpfi':
+                        case 'ebcdiccpse':
+                        case 'ibm278':
+                                return 'IBM278';
+
+                        case 'cp280':
+                        case 'csibm280':
+                        case 'ebcdiccpit':
+                        case 'ibm280':
+                                return 'IBM280';
+
+                        case 'cp281':
+                        case 'csibm281':
+                        case 'ebcdicjpe':
+                        case 'ibm281':
+                                return 'IBM281';
+
+                        case 'cp284':
+                        case 'csibm284':
+                        case 'ebcdiccpes':
+                        case 'ibm284':
+                                return 'IBM284';
+
+                        case 'cp285':
+                        case 'csibm285':
+                        case 'ebcdiccpgb':
+                        case 'ibm285':
+                                return 'IBM285';
+
+                        case 'cp290':
+                        case 'csibm290':
+                        case 'ebcdicjpkana':
+                        case 'ibm290':
+                                return 'IBM290';
+
+                        case 'cp297':
+                        case 'csibm297':
+                        case 'ebcdiccpfr':
+                        case 'ibm297':
+                                return 'IBM297';
+
+                        case 'cp420':
+                        case 'csibm420':
+                        case 'ebcdiccpar1':
+                        case 'ibm420':
+                                return 'IBM420';
+
+                        case 'cp423':
+                        case 'csibm423':
+                        case 'ebcdiccpgr':
+                        case 'ibm423':
+                                return 'IBM423';
+
+                        case 'cp424':
+                        case 'csibm424':
+                        case 'ebcdiccphe':
+                        case 'ibm424':
+                                return 'IBM424';
+
+                        case '437':
+                        case 'cp437':
+                        case 'cspc8codepage437':
+                        case 'ibm437':
+                                return 'IBM437';
+
+                        case 'cp500':
+                        case 'csibm500':
+                        case 'ebcdiccpbe':
+                        case 'ebcdiccpch':
+                        case 'ibm500':
+                                return 'IBM500';
+
+                        case 'cp775':
+                        case 'cspc775baltic':
+                        case 'ibm775':
+                                return 'IBM775';
+
+                        case '850':
+                        case 'cp850':
+                        case 'cspc850multilingual':
+                        case 'ibm850':
+                                return 'IBM850';
+
+                        case '851':
+                        case 'cp851':
+                        case 'csibm851':
+                        case 'ibm851':
+                                return 'IBM851';
+
+                        case '852':
+                        case 'cp852':
+                        case 'cspcp852':
+                        case 'ibm852':
+                                return 'IBM852';
+
+                        case '855':
+                        case 'cp855':
+                        case 'csibm855':
+                        case 'ibm855':
+                                return 'IBM855';
+
+                        case '857':
+                        case 'cp857':
+                        case 'csibm857':
+                        case 'ibm857':
+                                return 'IBM857';
+
+                        case 'ccsid858':
+                        case 'cp858':
+                        case 'ibm858':
+                        case 'pcmultilingual850euro':
+                                return 'IBM00858';
+
+                        case '860':
+                        case 'cp860':
+                        case 'csibm860':
+                        case 'ibm860':
+                                return 'IBM860';
+
+                        case '861':
+                        case 'cp861':
+                        case 'cpis':
+                        case 'csibm861':
+                        case 'ibm861':
+                                return 'IBM861';
+
+                        case '862':
+                        case 'cp862':
+                        case 'cspc862latinhebrew':
+                        case 'ibm862':
+                                return 'IBM862';
+
+                        case '863':
+                        case 'cp863':
+                        case 'csibm863':
+                        case 'ibm863':
+                                return 'IBM863';
+
+                        case 'cp864':
+                        case 'csibm864':
+                        case 'ibm864':
+                                return 'IBM864';
+
+                        case '865':
+                        case 'cp865':
+                        case 'csibm865':
+                        case 'ibm865':
+                                return 'IBM865';
+
+                        case '866':
+                        case 'cp866':
+                        case 'csibm866':
+                        case 'ibm866':
+                                return 'IBM866';
+
+                        case 'cp868':
+                        case 'cpar':
+                        case 'csibm868':
+                        case 'ibm868':
+                                return 'IBM868';
+
+                        case '869':
+                        case 'cp869':
+                        case 'cpgr':
+                        case 'csibm869':
+                        case 'ibm869':
+                                return 'IBM869';
+
+                        case 'cp870':
+                        case 'csibm870':
+                        case 'ebcdiccproece':
+                        case 'ebcdiccpyu':
+                        case 'ibm870':
+                                return 'IBM870';
+
+                        case 'cp871':
+                        case 'csibm871':
+                        case 'ebcdiccpis':
+                        case 'ibm871':
+                                return 'IBM871';
+
+                        case 'cp880':
+                        case 'csibm880':
+                        case 'ebcdiccyrillic':
+                        case 'ibm880':
+                                return 'IBM880';
+
+                        case 'cp891':
+                        case 'csibm891':
+                        case 'ibm891':
+                                return 'IBM891';
+
+                        case 'cp903':
+                        case 'csibm903':
+                        case 'ibm903':
+                                return 'IBM903';
+
+                        case '904':
+                        case 'cp904':
+                        case 'csibbm904':
+                        case 'ibm904':
+                                return 'IBM904';
+
+                        case 'cp905':
+                        case 'csibm905':
+                        case 'ebcdiccptr':
+                        case 'ibm905':
+                                return 'IBM905';
+
+                        case 'cp918':
+                        case 'csibm918':
+                        case 'ebcdiccpar2':
+                        case 'ibm918':
+                                return 'IBM918';
+
+                        case 'ccsid924':
+                        case 'cp924':
+                        case 'ebcdiclatin9euro':
+                        case 'ibm924':
+                                return 'IBM00924';
+
+                        case 'cp1026':
+                        case 'csibm1026':
+                        case 'ibm1026':
+                                return 'IBM1026';
+
+                        case 'ibm1047':
+                                return 'IBM1047';
+
+                        case 'ccsid1140':
+                        case 'cp1140':
+                        case 'ebcdicus37euro':
+                        case 'ibm1140':
+                                return 'IBM01140';
+
+                        case 'ccsid1141':
+                        case 'cp1141':
+                        case 'ebcdicde273euro':
+                        case 'ibm1141':
+                                return 'IBM01141';
+
+                        case 'ccsid1142':
+                        case 'cp1142':
+                        case 'ebcdicdk277euro':
+                        case 'ebcdicno277euro':
+                        case 'ibm1142':
+                                return 'IBM01142';
+
+                        case 'ccsid1143':
+                        case 'cp1143':
+                        case 'ebcdicfi278euro':
+                        case 'ebcdicse278euro':
+                        case 'ibm1143':
+                                return 'IBM01143';
+
+                        case 'ccsid1144':
+                        case 'cp1144':
+                        case 'ebcdicit280euro':
+                        case 'ibm1144':
+                                return 'IBM01144';
+
+                        case 'ccsid1145':
+                        case 'cp1145':
+                        case 'ebcdices284euro':
+                        case 'ibm1145':
+                                return 'IBM01145';
+
+                        case 'ccsid1146':
+                        case 'cp1146':
+                        case 'ebcdicgb285euro':
+                        case 'ibm1146':
+                                return 'IBM01146';
+
+                        case 'ccsid1147':
+                        case 'cp1147':
+                        case 'ebcdicfr297euro':
+                        case 'ibm1147':
+                                return 'IBM01147';
+
+                        case 'ccsid1148':
+                        case 'cp1148':
+                        case 'ebcdicinternational500euro':
+                        case 'ibm1148':
+                                return 'IBM01148';
+
+                        case 'ccsid1149':
+                        case 'cp1149':
+                        case 'ebcdicis871euro':
+                        case 'ibm1149':
+                                return 'IBM01149';
+
+                        case 'csiso143iecp271':
+                        case 'iecp271':
+                        case 'isoir143':
+                                return 'IEC_P27-1';
+
+                        case 'csiso49inis':
+                        case 'inis':
+                        case 'isoir49':
+                                return 'INIS';
+
+                        case 'csiso50inis8':
+                        case 'inis8':
+                        case 'isoir50':
+                                return 'INIS-8';
+
+                        case 'csiso51iniscyrillic':
+                        case 'iniscyrillic':
+                        case 'isoir51':
+                                return 'INIS-cyrillic';
+
+                        case 'csinvariant':
+                        case 'invariant':
+                                return 'INVARIANT';
+
+                        case 'iso2022cn':
+                                return 'ISO-2022-CN';
+
+                        case 'iso2022cnext':
+                                return 'ISO-2022-CN-EXT';
+
+                        case 'csiso2022jp':
+                        case 'iso2022jp':
+                                return 'ISO-2022-JP';
+
+                        case 'csiso2022jp2':
+                        case 'iso2022jp2':
+                                return 'ISO-2022-JP-2';
+
+                        case 'csiso2022kr':
+                        case 'iso2022kr':
+                                return 'ISO-2022-KR';
+
+                        case 'cswindows30latin1':
+                        case 'iso88591windows30latin1':
+                                return 'ISO-8859-1-Windows-3.0-Latin-1';
+
+                        case 'cswindows31latin1':
+                        case 'iso88591windows31latin1':
+                                return 'ISO-8859-1-Windows-3.1-Latin-1';
+
+                        case 'csisolatin2':
+                        case 'iso88592':
+                        case 'iso885921987':
+                        case 'isoir101':
+                        case 'l2':
+                        case 'latin2':
+                                return 'ISO-8859-2';
+
+                        case 'cswindows31latin2':
+                        case 'iso88592windowslatin2':
+                                return 'ISO-8859-2-Windows-Latin-2';
+
+                        case 'csisolatin3':
+                        case 'iso88593':
+                        case 'iso885931988':
+                        case 'isoir109':
+                        case 'l3':
+                        case 'latin3':
+                                return 'ISO-8859-3';
+
+                        case 'csisolatin4':
+                        case 'iso88594':
+                        case 'iso885941988':
+                        case 'isoir110':
+                        case 'l4':
+                        case 'latin4':
+                                return 'ISO-8859-4';
+
+                        case 'csisolatincyrillic':
+                        case 'cyrillic':
+                        case 'iso88595':
+                        case 'iso885951988':
+                        case 'isoir144':
+                                return 'ISO-8859-5';
+
+                        case 'arabic':
+                        case 'asmo708':
+                        case 'csisolatinarabic':
+                        case 'ecma114':
+                        case 'iso88596':
+                        case 'iso885961987':
+                        case 'isoir127':
+                                return 'ISO-8859-6';
+
+                        case 'csiso88596e':
+                        case 'iso88596e':
+                                return 'ISO-8859-6-E';
+
+                        case 'csiso88596i':
+                        case 'iso88596i':
+                                return 'ISO-8859-6-I';
+
+                        case 'csisolatingreek':
+                        case 'ecma118':
+                        case 'elot928':
+                        case 'greek':
+                        case 'greek8':
+                        case 'iso88597':
+                        case 'iso885971987':
+                        case 'isoir126':
+                                return 'ISO-8859-7';
+
+                        case 'csisolatinhebrew':
+                        case 'hebrew':
+                        case 'iso88598':
+                        case 'iso885981988':
+                        case 'isoir138':
+                                return 'ISO-8859-8';
+
+                        case 'csiso88598e':
+                        case 'iso88598e':
+                                return 'ISO-8859-8-E';
+
+                        case 'csiso88598i':
+                        case 'iso88598i':
+                                return 'ISO-8859-8-I';
+
+                        case 'cswindows31latin5':
+                        case 'iso88599windowslatin5':
+                                return 'ISO-8859-9-Windows-Latin-5';
+
+                        case 'csisolatin6':
+                        case 'iso885910':
+                        case 'iso8859101992':
+                        case 'isoir157':
+                        case 'l6':
+                        case 'latin6':
+                                return 'ISO-8859-10';
+
+                        case 'iso885913':
+                                return 'ISO-8859-13';
+
+                        case 'iso885914':
+                        case 'iso8859141998':
+                        case 'isoceltic':
+                        case 'isoir199':
+                        case 'l8':
+                        case 'latin8':
+                                return 'ISO-8859-14';
+
+                        case 'iso885915':
+                        case 'latin9':
+                                return 'ISO-8859-15';
+
+                        case 'iso885916':
+                        case 'iso8859162001':
+                        case 'isoir226':
+                        case 'l10':
+                        case 'latin10':
+                                return 'ISO-8859-16';
+
+                        case 'iso10646j1':
+                                return 'ISO-10646-J-1';
+
+                        case 'csunicode':
+                        case 'iso10646ucs2':
+                                return 'ISO-10646-UCS-2';
+
+                        case 'csucs4':
+                        case 'iso10646ucs4':
+                                return 'ISO-10646-UCS-4';
+
+                        case 'csunicodeascii':
+                        case 'iso10646ucsbasic':
+                                return 'ISO-10646-UCS-Basic';
+
+                        case 'csunicodelatin1':
+                        case 'iso10646':
+                        case 'iso10646unicodelatin1':
+                                return 'ISO-10646-Unicode-Latin1';
+
+                        case 'csiso10646utf1':
+                        case 'iso10646utf1':
+                                return 'ISO-10646-UTF-1';
+
+                        case 'csiso115481':
+                        case 'iso115481':
+                        case 'isotr115481':
+                                return 'ISO-11548-1';
+
+                        case 'csiso90':
+                        case 'isoir90':
+                                return 'iso-ir-90';
+
+                        case 'csunicodeibm1261':
+                        case 'isounicodeibm1261':
+                                return 'ISO-Unicode-IBM-1261';
+
+                        case 'csunicodeibm1264':
+                        case 'isounicodeibm1264':
+                                return 'ISO-Unicode-IBM-1264';
+
+                        case 'csunicodeibm1265':
+                        case 'isounicodeibm1265':
+                                return 'ISO-Unicode-IBM-1265';
+
+                        case 'csunicodeibm1268':
+                        case 'isounicodeibm1268':
+                                return 'ISO-Unicode-IBM-1268';
+
+                        case 'csunicodeibm1276':
+                        case 'isounicodeibm1276':
+                                return 'ISO-Unicode-IBM-1276';
+
+                        case 'csiso646basic1983':
+                        case 'iso646basic1983':
+                        case 'ref':
+                                return 'ISO_646.basic:1983';
+
+                        case 'csiso2intlrefversion':
+                        case 'irv':
+                        case 'iso646irv1983':
+                        case 'isoir2':
+                                return 'ISO_646.irv:1983';
+
+                        case 'csiso2033':
+                        case 'e13b':
+                        case 'iso20331983':
+                        case 'isoir98':
+                                return 'ISO_2033-1983';
+
+                        case 'csiso5427cyrillic':
+                        case 'iso5427':
+                        case 'isoir37':
+                                return 'ISO_5427';
+
+                        case 'iso5427cyrillic1981':
+                        case 'iso54271981':
+                        case 'isoir54':
+                                return 'ISO_5427:1981';
+
+                        case 'csiso5428greek':
+                        case 'iso54281980':
+                        case 'isoir55':
+                                return 'ISO_5428:1980';
+
+                        case 'csiso6937add':
+                        case 'iso6937225':
+                        case 'isoir152':
+                                return 'ISO_6937-2-25';
+
+                        case 'csisotextcomm':
+                        case 'iso69372add':
+                        case 'isoir142':
+                                return 'ISO_6937-2-add';
+
+                        case 'csiso8859supp':
+                        case 'iso8859supp':
+                        case 'isoir154':
+                        case 'latin125':
+                                return 'ISO_8859-supp';
+
+                        case 'csiso10367box':
+                        case 'iso10367box':
+                        case 'isoir155':
+                                return 'ISO_10367-box';
+
+                        case 'csiso15italian':
+                        case 'iso646it':
+                        case 'isoir15':
+                        case 'it':
+                                return 'IT';
+
+                        case 'csiso13jisc6220jp':
+                        case 'isoir13':
+                        case 'jisc62201969':
+                        case 'jisc62201969jp':
+                        case 'katakana':
+                        case 'x2017':
+                                return 'JIS_C6220-1969-jp';
+
+                        case 'csiso14jisc6220ro':
+                        case 'iso646jp':
+                        case 'isoir14':
+                        case 'jisc62201969ro':
+                        case 'jp':
+                                return 'JIS_C6220-1969-ro';
+
+                        case 'csiso42jisc62261978':
+                        case 'isoir42':
+                        case 'jisc62261978':
+                                return 'JIS_C6226-1978';
+
+                        case 'csiso87jisx208':
+                        case 'isoir87':
+                        case 'jisc62261983':
+                        case 'jisx2081983':
+                        case 'x208':
+                                return 'JIS_C6226-1983';
+
+                        case 'csiso91jisc62291984a':
+                        case 'isoir91':
+                        case 'jisc62291984a':
+                        case 'jpocra':
+                                return 'JIS_C6229-1984-a';
+
+                        case 'csiso92jisc62991984b':
+                        case 'iso646jpocrb':
+                        case 'isoir92':
+                        case 'jisc62291984b':
+                        case 'jpocrb':
+                                return 'JIS_C6229-1984-b';
+
+                        case 'csiso93jis62291984badd':
+                        case 'isoir93':
+                        case 'jisc62291984badd':
+                        case 'jpocrbadd':
+                                return 'JIS_C6229-1984-b-add';
+
+                        case 'csiso94jis62291984hand':
+                        case 'isoir94':
+                        case 'jisc62291984hand':
+                        case 'jpocrhand':
+                                return 'JIS_C6229-1984-hand';
+
+                        case 'csiso95jis62291984handadd':
+                        case 'isoir95':
+                        case 'jisc62291984handadd':
+                        case 'jpocrhandadd':
+                                return 'JIS_C6229-1984-hand-add';
+
+                        case 'csiso96jisc62291984kana':
+                        case 'isoir96':
+                        case 'jisc62291984kana':
+                                return 'JIS_C6229-1984-kana';
+
+                        case 'csjisencoding':
+                        case 'jisencoding':
+                                return 'JIS_Encoding';
+
+                        case 'cshalfwidthkatakana':
+                        case 'jisx201':
+                        case 'x201':
+                                return 'JIS_X0201';
+
+                        case 'csiso159jisx2121990':
+                        case 'isoir159':
+                        case 'jisx2121990':
+                        case 'x212':
+                                return 'JIS_X0212-1990';
+
+                        case 'csiso141jusib1002':
+                        case 'iso646yu':
+                        case 'isoir141':
+                        case 'js':
+                        case 'jusib1002':
+                        case 'yu':
+                                return 'JUS_I.B1.002';
+
+                        case 'csiso147macedonian':
+                        case 'isoir147':
+                        case 'jusib1003mac':
+                        case 'macedonian':
+                                return 'JUS_I.B1.003-mac';
+
+                        case 'csiso146serbian':
+                        case 'isoir146':
+                        case 'jusib1003serb':
+                        case 'serbian':
+                                return 'JUS_I.B1.003-serb';
+
+                        case 'koi7switched':
+                                return 'KOI7-switched';
+
+                        case 'cskoi8r':
+                        case 'koi8r':
+                                return 'KOI8-R';
+
+                        case 'koi8u':
+                                return 'KOI8-U';
+
+                        case 'csksc5636':
+                        case 'iso646kr':
+                        case 'ksc5636':
+                                return 'KSC5636';
+
+                        case 'cskz1048':
+                        case 'kz1048':
+                        case 'rk1048':
+                        case 'strk10482002':
+                                return 'KZ-1048';
+
+                        case 'csiso19latingreek':
+                        case 'isoir19':
+                        case 'latingreek':
+                                return 'latin-greek';
+
+                        case 'csiso27latingreek1':
+                        case 'isoir27':
+                        case 'latingreek1':
+                                return 'Latin-greek-1';
+
+                        case 'csiso158lap':
+                        case 'isoir158':
+                        case 'lap':
+                        case 'latinlap':
+                                return 'latin-lap';
+
+                        case 'csmacintosh':
+                        case 'mac':
+                        case 'macintosh':
+                                return 'macintosh';
+
+                        case 'csmicrosoftpublishing':
+                        case 'microsoftpublishing':
+                                return 'Microsoft-Publishing';
+
+                        case 'csmnem':
+                        case 'mnem':
+                                return 'MNEM';
+
+                        case 'csmnemonic':
+                        case 'mnemonic':
+                                return 'MNEMONIC';
+
+                        case 'csiso86hungarian':
+                        case 'hu':
+                        case 'iso646hu':
+                        case 'isoir86':
+                        case 'msz77953':
+                                return 'MSZ_7795.3';
+
+                        case 'csnatsdano':
+                        case 'isoir91':
+                        case 'natsdano':
+                                return 'NATS-DANO';
+
+                        case 'csnatsdanoadd':
+                        case 'isoir92':
+                        case 'natsdanoadd':
+                                return 'NATS-DANO-ADD';
+
+                        case 'csnatssefi':
+                        case 'isoir81':
+                        case 'natssefi':
+                                return 'NATS-SEFI';
+
+                        case 'csnatssefiadd':
+                        case 'isoir82':
+                        case 'natssefiadd':
+                                return 'NATS-SEFI-ADD';
+
+                        case 'csiso151cuba':
+                        case 'cuba':
+                        case 'iso646cu':
+                        case 'isoir151':
+                        case 'ncnc1081':
+                                return 'NC_NC00-10:81';
+
+                        case 'csiso69french':
+                        case 'fr':
+                        case 'iso646fr':
+                        case 'isoir69':
+                        case 'nfz62010':
+                                return 'NF_Z_62-010';
+
+                        case 'csiso25french':
+                        case 'iso646fr1':
+                        case 'isoir25':
+                        case 'nfz620101973':
+                                return 'NF_Z_62-010_(1973)';
+
+                        case 'csiso60danishnorwegian':
+                        case 'csiso60norwegian1':
+                        case 'iso646no':
+                        case 'isoir60':
+                        case 'no':
+                        case 'ns45511':
+                                return 'NS_4551-1';
+
+                        case 'csiso61norwegian2':
+                        case 'iso646no2':
+                        case 'isoir61':
+                        case 'no2':
+                        case 'ns45512':
+                                return 'NS_4551-2';
+
+                        case 'osdebcdicdf3irv':
+                                return 'OSD_EBCDIC_DF03_IRV';
+
+                        case 'osdebcdicdf41':
+                                return 'OSD_EBCDIC_DF04_1';
+
+                        case 'osdebcdicdf415':
+                                return 'OSD_EBCDIC_DF04_15';
+
+                        case 'cspc8danishnorwegian':
+                        case 'pc8danishnorwegian':
+                                return 'PC8-Danish-Norwegian';
+
+                        case 'cspc8turkish':
+                        case 'pc8turkish':
+                                return 'PC8-Turkish';
+
+                        case 'csiso16portuguese':
+                        case 'iso646pt':
+                        case 'isoir16':
+                        case 'pt':
+                                return 'PT';
+
+                        case 'csiso84portuguese2':
+                        case 'iso646pt2':
+                        case 'isoir84':
+                        case 'pt2':
+                                return 'PT2';
+
+                        case 'cp154':
+                        case 'csptcp154':
+                        case 'cyrillicasian':
+                        case 'pt154':
+                        case 'ptcp154':
+                                return 'PTCP154';
+
+                        case 'scsu':
+                                return 'SCSU';
+
+                        case 'csiso10swedish':
+                        case 'fi':
+                        case 'iso646fi':
+                        case 'iso646se':
+                        case 'isoir10':
+                        case 'se':
+                        case 'sen850200b':
+                                return 'SEN_850200_B';
+
+                        case 'csiso11swedishfornames':
+                        case 'iso646se2':
+                        case 'isoir11':
+                        case 'se2':
+                        case 'sen850200c':
+                                return 'SEN_850200_C';
+
+                        case 'csiso102t617bit':
+                        case 'isoir102':
+                        case 't617bit':
+                                return 'T.61-7bit';
+
+                        case 'csiso103t618bit':
+                        case 'isoir103':
+                        case 't61':
+                        case 't618bit':
+                                return 'T.61-8bit';
+
+                        case 'csiso128t101g2':
+                        case 'isoir128':
+                        case 't101g2':
+                                return 'T.101-G2';
+
+                        case 'cstscii':
+                        case 'tscii':
+                                return 'TSCII';
+
+                        case 'csunicode11':
+                        case 'unicode11':
+                                return 'UNICODE-1-1';
+
+                        case 'csunicode11utf7':
+                        case 'unicode11utf7':
+                                return 'UNICODE-1-1-UTF-7';
+
+                        case 'csunknown8bit':
+                        case 'unknown8bit':
+                                return 'UNKNOWN-8BIT';
+
+                        case 'ansix341968':
+                        case 'ansix341986':
+                        case 'ascii':
+                        case 'cp367':
+                        case 'csascii':
+                        case 'ibm367':
+                        case 'iso646irv1991':
+                        case 'iso646us':
+                        case 'isoir6':
+                        case 'us':
+                        case 'usascii':
+                                return 'US-ASCII';
+
+                        case 'csusdk':
+                        case 'usdk':
+                                return 'us-dk';
+
+                        case 'utf7':
+                                return 'UTF-7';
+
+                        case 'utf8':
+                                return 'UTF-8';
+
+                        case 'utf16':
+                                return 'UTF-16';
+
+                        case 'utf16be':
+                                return 'UTF-16BE';
+
+                        case 'utf16le':
+                                return 'UTF-16LE';
+
+                        case 'utf32':
+                                return 'UTF-32';
+
+                        case 'utf32be':
+                                return 'UTF-32BE';
+
+                        case 'utf32le':
+                                return 'UTF-32LE';
+
+                        case 'csventurainternational':
+                        case 'venturainternational':
+                                return 'Ventura-International';
+
+                        case 'csventuramath':
+                        case 'venturamath':
+                                return 'Ventura-Math';
+
+                        case 'csventuraus':
+                        case 'venturaus':
+                                return 'Ventura-US';
+
+                        case 'csiso70videotexsupp1':
+                        case 'isoir70':
+                        case 'videotexsuppl':
+                                return 'videotex-suppl';
+
+                        case 'csviqr':
+                        case 'viqr':
+                                return 'VIQR';
+
+                        case 'csviscii':
+                        case 'viscii':
+                                return 'VISCII';
+
+                        case 'csshiftjis':
+                        case 'cswindows31j':
+                        case 'mskanji':
+                        case 'shiftjis':
+                        case 'windows31j':
+                                return 'Windows-31J';
+
+                        case 'iso885911':
+                        case 'tis620':
+                                return 'windows-874';
+
+                        case 'cseuckr':
+                        case 'csksc56011987':
+                        case 'euckr':
+                        case 'isoir149':
+                        case 'korean':
+                        case 'ksc5601':
+                        case 'ksc56011987':
+                        case 'ksc56011989':
+                        case 'windows949':
+                                return 'windows-949';
+
+                        case 'windows1250':
+                                return 'windows-1250';
+
+                        case 'windows1251':
+                                return 'windows-1251';
+
+                        case 'cp819':
+                        case 'csisolatin1':
+                        case 'ibm819':
+                        case 'iso88591':
+                        case 'iso885911987':
+                        case 'isoir100':
+                        case 'l1':
+                        case 'latin1':
+                        case 'windows1252':
+                                return 'windows-1252';
+
+                        case 'windows1253':
+                                return 'windows-1253';
+
+                        case 'csisolatin5':
+                        case 'iso88599':
+                        case 'iso885991989':
+                        case 'isoir148':
+                        case 'l5':
+                        case 'latin5':
+                        case 'windows1254':
+                                return 'windows-1254';
+
+                        case 'windows1255':
+                                return 'windows-1255';
+
+                        case 'windows1256':
+                                return 'windows-1256';
+
+                        case 'windows1257':
+                                return 'windows-1257';
+
+                        case 'windows1258':
+                                return 'windows-1258';
+
+                        default:
+                                return $charset;
+                }
+        }
+
+        public static function get_curl_version()
+        {
+                if (is_array($curl = curl_version()))
+                {
+                        $curl = $curl['version'];
+                }
+                elseif (substr($curl, 0, 5) === 'curl/')
+                {
+                        $curl = substr($curl, 5, strcspn($curl, "\x09\x0A\x0B\x0C\x0D", 5));
+                }
+                elseif (substr($curl, 0, 8) === 'libcurl/')
+                {
+                        $curl = substr($curl, 8, strcspn($curl, "\x09\x0A\x0B\x0C\x0D", 8));
+                }
+                else
+                {
+                        $curl = 0;
+                }
+                return $curl;
+        }
+
+        /**
+         * Strip HTML comments
+         *
+         * @param string $data Data to strip comments from
+         * @return string Comment stripped string
+         */
+        public static function strip_comments($data)
+        {
+                $output = '';
+                while (($start = strpos($data, '<!--')) !== false)
+                {
+                        $output .= substr($data, 0, $start);
+                        if (($end = strpos($data, '-->', $start)) !== false)
+                        {
+                                $data = substr_replace($data, '', 0, $end + 3);
+                        }
+                        else
+                        {
+                                $data = '';
+                        }
+                }
+                return $output . $data;
+        }
+
+        public static function parse_date($dt)
+        {
+                $parser = SimplePie_Parse_Date::get();
+                return $parser->parse($dt);
+        }
+
+        /**
+         * Decode HTML entities
+         *
+         * @deprecated Use DOMDocument instead
+         * @param string $data Input data
+         * @return string Output data
+         */
+        public static function entities_decode($data)
+        {
+                $decoder = new SimplePie_Decode_HTML_Entities($data);
+                return $decoder->parse();
+        }
+
+        /**
+         * Remove RFC822 comments
+         *
+         * @param string $data Data to strip comments from
+         * @return string Comment stripped string
+         */
+        public static function uncomment_rfc822($string)
+        {
+                $string = (string) $string;
+                $position = 0;
+                $length = strlen($string);
+                $depth = 0;
+
+                $output = '';
+
+                while ($position < $length && ($pos = strpos($string, '(', $position)) !== false)
+                {
+                        $output .= substr($string, $position, $pos - $position);
+                        $position = $pos + 1;
+                        if ($string[$pos - 1] !== '\\')
+                        {
+                                $depth++;
+                                while ($depth && $position < $length)
+                                {
+                                        $position += strcspn($string, '()', $position);
+                                        if ($string[$position - 1] === '\\')
+                                        {
+                                                $position++;
+                                                continue;
+                                        }
+                                        elseif (isset($string[$position]))
+                                        {
+                                                switch ($string[$position])
+                                                {
+                                                        case '(':
+                                                                $depth++;
+                                                                break;
+
+                                                        case ')':
+                                                                $depth--;
+                                                                break;
+                                                }
+                                                $position++;
+                                        }
+                                        else
+                                        {
+                                                break;
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                $output .= '(';
+                        }
+                }
+                $output .= substr($string, $position);
+
+                return $output;
+        }
+
+        public static function parse_mime($mime)
+        {
+                if (($pos = strpos($mime, ';')) === false)
+                {
+                        return trim($mime);
+                }
+                else
+                {
+                        return trim(substr($mime, 0, $pos));
+                }
+        }
+
+        public static function atom_03_construct_type($attribs)
+        {
+                if (isset($attribs['']['mode']) && strtolower(trim($attribs['']['mode']) === 'base64'))
+                {
+                        $mode = SIMPLEPIE_CONSTRUCT_BASE64;
+                }
+                else
+                {
+                        $mode = SIMPLEPIE_CONSTRUCT_NONE;
+                }
+                if (isset($attribs['']['type']))
+                {
+                        switch (strtolower(trim($attribs['']['type'])))
+                        {
+                                case 'text':
+                                case 'text/plain':
+                                        return SIMPLEPIE_CONSTRUCT_TEXT | $mode;
+
+                                case 'html':
+                                case 'text/html':
+                                        return SIMPLEPIE_CONSTRUCT_HTML | $mode;
+
+                                case 'xhtml':
+                                case 'application/xhtml+xml':
+                                        return SIMPLEPIE_CONSTRUCT_XHTML | $mode;
+
+                                default:
+                                        return SIMPLEPIE_CONSTRUCT_NONE | $mode;
+                        }
+                }
+                else
+                {
+                        return SIMPLEPIE_CONSTRUCT_TEXT | $mode;
+                }
+        }
+
+        public static function atom_10_construct_type($attribs)
+        {
+                if (isset($attribs['']['type']))
+                {
+                        switch (strtolower(trim($attribs['']['type'])))
+                        {
+                                case 'text':
+                                        return SIMPLEPIE_CONSTRUCT_TEXT;
+
+                                case 'html':
+                                        return SIMPLEPIE_CONSTRUCT_HTML;
+
+                                case 'xhtml':
+                                        return SIMPLEPIE_CONSTRUCT_XHTML;
+
+                                default:
+                                        return SIMPLEPIE_CONSTRUCT_NONE;
+                        }
+                }
+                return SIMPLEPIE_CONSTRUCT_TEXT;
+        }
+
+        public static function atom_10_content_construct_type($attribs)
+        {
+                if (isset($attribs['']['type']))
+                {
+                        $type = strtolower(trim($attribs['']['type']));
+                        switch ($type)
+                        {
+                                case 'text':
+                                        return SIMPLEPIE_CONSTRUCT_TEXT;
+
+                                case 'html':
+                                        return SIMPLEPIE_CONSTRUCT_HTML;
+
+                                case 'xhtml':
+                                        return SIMPLEPIE_CONSTRUCT_XHTML;
+                        }
+                        if (in_array(substr($type, -4), array('+xml', '/xml')) || substr($type, 0, 5) === 'text/')
+                        {
+                                return SIMPLEPIE_CONSTRUCT_NONE;
+                        }
+                        else
+                        {
+                                return SIMPLEPIE_CONSTRUCT_BASE64;
+                        }
+                }
+                else
+                {
+                        return SIMPLEPIE_CONSTRUCT_TEXT;
+                }
+        }
+
+        public static function is_isegment_nz_nc($string)
+        {
+                return (bool) preg_match('/^([A-Za-z0-9\-._~\x{A0}-\x{D7FF}\x{F900}-\x{FDCF}\x{FDF0}-\x{FFEF}\x{10000}-\x{1FFFD}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}\x{40000}-\x{4FFFD}\x{50000}-\x{5FFFD}\x{60000}-\x{6FFFD}\x{70000}-\x{7FFFD}\x{80000}-\x{8FFFD}\x{90000}-\x{9FFFD}\x{A0000}-\x{AFFFD}\x{B0000}-\x{BFFFD}\x{C0000}-\x{CFFFD}\x{D0000}-\x{DFFFD}\x{E1000}-\x{EFFFD}!$&\'()*+,;=@]|(%[0-9ABCDEF]{2}))+$/u', $string);
+        }
+
+        public static function space_seperated_tokens($string)
+        {
+                $space_characters = "\x20\x09\x0A\x0B\x0C\x0D";
+                $string_length = strlen($string);
+
+                $position = strspn($string, $space_characters);
+                $tokens = array();
+
+                while ($position < $string_length)
+                {
+                        $len = strcspn($string, $space_characters, $position);
+                        $tokens[] = substr($string, $position, $len);
+                        $position += $len;
+                        $position += strspn($string, $space_characters, $position);
+                }
+
+                return $tokens;
+        }
+
+        /**
+         * Converts a unicode codepoint to a UTF-8 character
+         *
+         * @static
+         * @param int $codepoint Unicode codepoint
+         * @return string UTF-8 character
+         */
+        public static function codepoint_to_utf8($codepoint)
+        {
+                $codepoint = (int) $codepoint;
+                if ($codepoint < 0)
+                {
+                        return false;
+                }
+                else if ($codepoint <= 0x7f)
+                {
+                        return chr($codepoint);
+                }
+                else if ($codepoint <= 0x7ff)
+                {
+                        return chr(0xc0 | ($codepoint >> 6)) . chr(0x80 | ($codepoint & 0x3f));
+                }
+                else if ($codepoint <= 0xffff)
+                {
+                        return chr(0xe0 | ($codepoint >> 12)) . chr(0x80 | (($codepoint >> 6) & 0x3f)) . chr(0x80 | ($codepoint & 0x3f));
+                }
+                else if ($codepoint <= 0x10ffff)
+                {
+                        return chr(0xf0 | ($codepoint >> 18)) . chr(0x80 | (($codepoint >> 12) & 0x3f)) . chr(0x80 | (($codepoint >> 6) & 0x3f)) . chr(0x80 | ($codepoint & 0x3f));
+                }
+                else
+                {
+                        // U+FFFD REPLACEMENT CHARACTER
+                        return "\xEF\xBF\xBD";
+                }
+        }
+
+        /**
+         * Similar to parse_str()
+         *
+         * Returns an associative array of name/value pairs, where the value is an
+         * array of values that have used the same name
+         *
+         * @static
+         * @param string $str The input string.
+         * @return array
+         */
+        public static function parse_str($str)
+        {
+                $return = array();
+                $str = explode('&', $str);
+
+                foreach ($str as $section)
+                {
+                        if (strpos($section, '=') !== false)
+                        {
+                                list($name, $value) = explode('=', $section, 2);
+                                $return[urldecode($name)][] = urldecode($value);
+                        }
+                        else
+                        {
+                                $return[urldecode($section)][] = null;
+                        }
+                }
+
+                return $return;
+        }
+
+        /**
+         * Detect XML encoding, as per XML 1.0 Appendix F.1
+         *
+         * @todo Add support for EBCDIC
+         * @param string $data XML data
+         * @param SimplePie_Registry $registry Class registry
+         * @return array Possible encodings
+         */
+        public static function xml_encoding($data, $registry)
+        {
+                // UTF-32 Big Endian BOM
+                if (substr($data, 0, 4) === "\x00\x00\xFE\xFF")
+                {
+                        $encoding[] = 'UTF-32BE';
+                }
+                // UTF-32 Little Endian BOM
+                elseif (substr($data, 0, 4) === "\xFF\xFE\x00\x00")
+                {
+                        $encoding[] = 'UTF-32LE';
+                }
+                // UTF-16 Big Endian BOM
+                elseif (substr($data, 0, 2) === "\xFE\xFF")
+                {
+                        $encoding[] = 'UTF-16BE';
+                }
+                // UTF-16 Little Endian BOM
+                elseif (substr($data, 0, 2) === "\xFF\xFE")
+                {
+                        $encoding[] = 'UTF-16LE';
+                }
+                // UTF-8 BOM
+                elseif (substr($data, 0, 3) === "\xEF\xBB\xBF")
+                {
+                        $encoding[] = 'UTF-8';
+                }
+                // UTF-32 Big Endian Without BOM
+                elseif (substr($data, 0, 20) === "\x00\x00\x00\x3C\x00\x00\x00\x3F\x00\x00\x00\x78\x00\x00\x00\x6D\x00\x00\x00\x6C")
+                {
+                        if ($pos = strpos($data, "\x00\x00\x00\x3F\x00\x00\x00\x3E"))
+                        {
+                                $parser = $registry->create('XML_Declaration_Parser', array(SimplePie_Misc::change_encoding(substr($data, 20, $pos - 20), 'UTF-32BE', 'UTF-8')));
+                                if ($parser->parse())
+                                {
+                                        $encoding[] = $parser->encoding;
+                                }
+                        }
+                        $encoding[] = 'UTF-32BE';
+                }
+                // UTF-32 Little Endian Without BOM
+                elseif (substr($data, 0, 20) === "\x3C\x00\x00\x00\x3F\x00\x00\x00\x78\x00\x00\x00\x6D\x00\x00\x00\x6C\x00\x00\x00")
+                {
+                        if ($pos = strpos($data, "\x3F\x00\x00\x00\x3E\x00\x00\x00"))
+                        {
+                                $parser = $registry->create('XML_Declaration_Parser', array(SimplePie_Misc::change_encoding(substr($data, 20, $pos - 20), 'UTF-32LE', 'UTF-8')));
+                                if ($parser->parse())
+                                {
+                                        $encoding[] = $parser->encoding;
+                                }
+                        }
+                        $encoding[] = 'UTF-32LE';
+                }
+                // UTF-16 Big Endian Without BOM
+                elseif (substr($data, 0, 10) === "\x00\x3C\x00\x3F\x00\x78\x00\x6D\x00\x6C")
+                {
+                        if ($pos = strpos($data, "\x00\x3F\x00\x3E"))
+                        {
+                                $parser = $registry->create('XML_Declaration_Parser', array(SimplePie_Misc::change_encoding(substr($data, 20, $pos - 10), 'UTF-16BE', 'UTF-8')));
+                                if ($parser->parse())
+                                {
+                                        $encoding[] = $parser->encoding;
+                                }
+                        }
+                        $encoding[] = 'UTF-16BE';
+                }
+                // UTF-16 Little Endian Without BOM
+                elseif (substr($data, 0, 10) === "\x3C\x00\x3F\x00\x78\x00\x6D\x00\x6C\x00")
+                {
+                        if ($pos = strpos($data, "\x3F\x00\x3E\x00"))
+                        {
+                                $parser = $registry->create('XML_Declaration_Parser', array(SimplePie_Misc::change_encoding(substr($data, 20, $pos - 10), 'UTF-16LE', 'UTF-8')));
+                                if ($parser->parse())
+                                {
+                                        $encoding[] = $parser->encoding;
+                                }
+                        }
+                        $encoding[] = 'UTF-16LE';
+                }
+                // US-ASCII (or superset)
+                elseif (substr($data, 0, 5) === "\x3C\x3F\x78\x6D\x6C")
+                {
+                        if ($pos = strpos($data, "\x3F\x3E"))
+                        {
+                                $parser = $registry->create('XML_Declaration_Parser', array(substr($data, 5, $pos - 5)));
+                                if ($parser->parse())
+                                {
+                                        $encoding[] = $parser->encoding;
+                                }
+                        }
+                        $encoding[] = 'UTF-8';
+                }
+                // Fallback to UTF-8
+                else
+                {
+                        $encoding[] = 'UTF-8';
+                }
+                return $encoding;
+        }
+
+        public static function output_javascript()
+        {
+                if (function_exists('ob_gzhandler'))
+                {
+                        ob_start('ob_gzhandler');
+                }
+                header('Content-type: text/javascript; charset: UTF-8');
+                header('Cache-Control: must-revalidate');
+                header('Expires: ' . gmdate('D, d M Y H:i:s', time() + 604800) . ' GMT'); // 7 days
+                ?>
+function embed_quicktime(type, bgcolor, width, height, link, placeholder, loop) {
+        if (placeholder != '') {
+                document.writeln('<embed type="'+type+'" style="cursor:hand; cursor:pointer;" href="'+link+'" src="'+placeholder+'" width="'+width+'" height="'+height+'" autoplay="false" target="myself" controller="false" loop="'+loop+'" scale="aspect" bgcolor="'+bgcolor+'" pluginspage="http://www.apple.com/quicktime/download/"></embed>');
+        }
+        else {
+                document.writeln('<embed type="'+type+'" style="cursor:hand; cursor:pointer;" src="'+link+'" width="'+width+'" height="'+height+'" autoplay="false" target="myself" controller="true" loop="'+loop+'" scale="aspect" bgcolor="'+bgcolor+'" pluginspage="http://www.apple.com/quicktime/download/"></embed>');
+        }
+}
+
+function embed_flash(bgcolor, width, height, link, loop, type) {
+        document.writeln('<embed src="'+link+'" pluginspage="http://www.macromedia.com/go/getflashplayer" type="'+type+'" quality="high" width="'+width+'" height="'+height+'" bgcolor="'+bgcolor+'" loop="'+loop+'"></embed>');
+}
+
+function embed_flv(width, height, link, placeholder, loop, player) {
+        document.writeln('<embed src="'+player+'" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" quality="high" width="'+width+'" height="'+height+'" wmode="transparent" flashvars="file='+link+'&autostart=false&repeat='+loop+'&showdigits=true&showfsbutton=false"></embed>');
+}
+
+function embed_wmedia(width, height, link) {
+        document.writeln('<embed type="application/x-mplayer2" src="'+link+'" autosize="1" width="'+width+'" height="'+height+'" showcontrols="1" showstatusbar="0" showdisplay="0" autostart="0"></embed>');
+}
+                <?php
+        }
+
+        /**
+         * Get the SimplePie build timestamp
+         *
+         * Uses the git index if it exists, otherwise uses the modification time
+         * of the newest file.
+         */
+        public static function get_build()
+        {
+                $root = dirname(dirname(__FILE__));
+                if (file_exists($root . '/.git/index'))
+                {
+                        return filemtime($root . '/.git/index');
+                }
+                elseif (file_exists($root . '/SimplePie'))
+                {
+                        $time = 0;
+                        foreach (glob($root . '/SimplePie/*.php') as $file)
+                        {
+                                if (($mtime = filemtime($file)) > $time)
+                                {
+                                        $time = $mtime;
+                                }
+                        }
+                        return $time;
+                }
+                elseif (file_exists(dirname(__FILE__) . '/Core.php'))
+                {
+                        return filemtime(dirname(__FILE__) . '/Core.php');
+                }
+                else
+                {
+                        return filemtime(__FILE__);
+                }
+        }
+
+        /**
+         * Format debugging information
+         */
+        public static function debug(&$sp)
+        {
+                $info = 'SimplePie ' . SIMPLEPIE_VERSION . ' Build ' . SIMPLEPIE_BUILD . "\n";
+                $info .= 'PHP ' . PHP_VERSION . "\n";
+                if ($sp->error() !== null)
+                {
+                        $info .= 'Error occurred: ' . $sp->error() . "\n";
+                }
+                else
+                {
+                        $info .= "No error found.\n";
+                }
+                $info .= "Extensions:\n";
+                $extensions = array('pcre', 'curl', 'zlib', 'mbstring', 'iconv', 'xmlreader', 'xml');
+                foreach ($extensions as $ext)
+                {
+                        if (extension_loaded($ext))
+                        {
+                                $info .= "    $ext loaded\n";
+                                switch ($ext)
+                                {
+                                        case 'pcre':
+                                                $info .= '      Version ' . PCRE_VERSION . "\n";
+                                                break;
+                                        case 'curl':
+                                                $version = curl_version();
+                                                $info .= '      Version ' . $version['version'] . "\n";
+                                                break;
+                                        case 'mbstring':
+                                                $info .= '      Overloading: ' . mb_get_info('func_overload') . "\n";
+                                                break;
+                                        case 'iconv':
+                                                $info .= '      Version ' . ICONV_VERSION . "\n";
+                                                break;
+                                        case 'xml':
+                                                $info .= '      Version ' . LIBXML_DOTTED_VERSION . "\n";
+                                                break;
+                                }
+                        }
+                        else
+                        {
+                                $info .= "    $ext not loaded\n";
+                        }
+                }
+                return $info;
+        }
+
+        public static function silence_errors($num, $str)
+        {
+                // No-op
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Net/IPv6.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Net/IPv6.php
new file mode 100644
index 00000000..da80d8ac
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Net/IPv6.php
@@ -0,0 +1,276 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Class to validate and to work with IPv6 addresses.
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ * @copyright 2003-2005 The PHP Group
+ * @license http://www.opensource.org/licenses/bsd-license.php
+ * @link http://pear.php.net/package/Net_IPv6
+ * @author Alexander Merz <alexander.merz@web.de>
+ * @author elfrink at introweb dot nl
+ * @author Josh Peck <jmp at joshpeck dot org>
+ * @author Geoffrey Sneddon <geoffers@gmail.com>
+ */
+class SimplePie_Net_IPv6
+{
+        /**
+         * Uncompresses an IPv6 address
+         *
+         * RFC 4291 allows you to compress concecutive zero pieces in an address to
+         * '::'. This method expects a valid IPv6 address and expands the '::' to
+         * the required number of zero pieces.
+         *
+         * Example:  FF01::101   ->  FF01:0:0:0:0:0:0:101
+         *           ::1         ->  0:0:0:0:0:0:0:1
+         *
+         * @author Alexander Merz <alexander.merz@web.de>
+         * @author elfrink at introweb dot nl
+         * @author Josh Peck <jmp at joshpeck dot org>
+         * @copyright 2003-2005 The PHP Group
+         * @license http://www.opensource.org/licenses/bsd-license.php
+         * @param string $ip An IPv6 address
+         * @return string The uncompressed IPv6 address
+         */
+        public static function uncompress($ip)
+        {
+                $c1 = -1;
+                $c2 = -1;
+                if (substr_count($ip, '::') === 1)
+                {
+                        list($ip1, $ip2) = explode('::', $ip);
+                        if ($ip1 === '')
+                        {
+                                $c1 = -1;
+                        }
+                        else
+                        {
+                                $c1 = substr_count($ip1, ':');
+                        }
+                        if ($ip2 === '')
+                        {
+                                $c2 = -1;
+                        }
+                        else
+                        {
+                                $c2 = substr_count($ip2, ':');
+                        }
+                        if (strpos($ip2, '.') !== false)
+                        {
+                                $c2++;
+                        }
+                        // ::
+                        if ($c1 === -1 && $c2 === -1)
+                        {
+                                $ip = '0:0:0:0:0:0:0:0';
+                        }
+                        // ::xxx
+                        else if ($c1 === -1)
+                        {
+                                $fill = str_repeat('0:', 7 - $c2);
+                                $ip = str_replace('::', $fill, $ip);
+                        }
+                        // xxx::
+                        else if ($c2 === -1)
+                        {
+                                $fill = str_repeat(':0', 7 - $c1);
+                                $ip = str_replace('::', $fill, $ip);
+                        }
+                        // xxx::xxx
+                        else
+                        {
+                                $fill = ':' . str_repeat('0:', 6 - $c2 - $c1);
+                                $ip = str_replace('::', $fill, $ip);
+                        }
+                }
+                return $ip;
+        }
+
+        /**
+         * Compresses an IPv6 address
+         *
+         * RFC 4291 allows you to compress concecutive zero pieces in an address to
+         * '::'. This method expects a valid IPv6 address and compresses consecutive
+         * zero pieces to '::'.
+         *
+         * Example:  FF01:0:0:0:0:0:0:101   ->  FF01::101
+         *           0:0:0:0:0:0:0:1        ->  ::1
+         *
+         * @see uncompress()
+         * @param string $ip An IPv6 address
+         * @return string The compressed IPv6 address
+         */
+        public static function compress($ip)
+        {
+                // Prepare the IP to be compressed
+                $ip = self::uncompress($ip);
+                $ip_parts = self::split_v6_v4($ip);
+
+                // Replace all leading zeros
+                $ip_parts[0] = preg_replace('/(^|:)0+([0-9])/', '\1\2', $ip_parts[0]);
+
+                // Find bunches of zeros
+                if (preg_match_all('/(?:^|:)(?:0(?::|$))+/', $ip_parts[0], $matches, PREG_OFFSET_CAPTURE))
+                {
+                        $max = 0;
+                        $pos = null;
+                        foreach ($matches[0] as $match)
+                        {
+                                if (strlen($match[0]) > $max)
+                                {
+                                        $max = strlen($match[0]);
+                                        $pos = $match[1];
+                                }
+                        }
+
+                        $ip_parts[0] = substr_replace($ip_parts[0], '::', $pos, $max);
+                }
+
+                if ($ip_parts[1] !== '')
+                {
+                        return implode(':', $ip_parts);
+                }
+                else
+                {
+                        return $ip_parts[0];
+                }
+        }
+
+        /**
+         * Splits an IPv6 address into the IPv6 and IPv4 representation parts
+         *
+         * RFC 4291 allows you to represent the last two parts of an IPv6 address
+         * using the standard IPv4 representation
+         *
+         * Example:  0:0:0:0:0:0:13.1.68.3
+         *           0:0:0:0:0:FFFF:129.144.52.38
+         *
+         * @param string $ip An IPv6 address
+         * @return array [0] contains the IPv6 represented part, and [1] the IPv4 represented part
+         */
+        private static function split_v6_v4($ip)
+        {
+                if (strpos($ip, '.') !== false)
+                {
+                        $pos = strrpos($ip, ':');
+                        $ipv6_part = substr($ip, 0, $pos);
+                        $ipv4_part = substr($ip, $pos + 1);
+                        return array($ipv6_part, $ipv4_part);
+                }
+                else
+                {
+                        return array($ip, '');
+                }
+        }
+
+        /**
+         * Checks an IPv6 address
+         *
+         * Checks if the given IP is a valid IPv6 address
+         *
+         * @param string $ip An IPv6 address
+         * @return bool true if $ip is a valid IPv6 address
+         */
+        public static function check_ipv6($ip)
+        {
+                $ip = self::uncompress($ip);
+                list($ipv6, $ipv4) = self::split_v6_v4($ip);
+                $ipv6 = explode(':', $ipv6);
+                $ipv4 = explode('.', $ipv4);
+                if (count($ipv6) === 8 && count($ipv4) === 1 || count($ipv6) === 6 && count($ipv4) === 4)
+                {
+                        foreach ($ipv6 as $ipv6_part)
+                        {
+                                // The section can't be empty
+                                if ($ipv6_part === '')
+                                        return false;
+
+                                // Nor can it be over four characters
+                                if (strlen($ipv6_part) > 4)
+                                        return false;
+
+                                // Remove leading zeros (this is safe because of the above)
+                                $ipv6_part = ltrim($ipv6_part, '0');
+                                if ($ipv6_part === '')
+                                        $ipv6_part = '0';
+
+                                // Check the value is valid
+                                $value = hexdec($ipv6_part);
+                                if (dechex($value) !== strtolower($ipv6_part) || $value < 0 || $value > 0xFFFF)
+                                        return false;
+                        }
+                        if (count($ipv4) === 4)
+                        {
+                                foreach ($ipv4 as $ipv4_part)
+                                {
+                                        $value = (int) $ipv4_part;
+                                        if ((string) $value !== $ipv4_part || $value < 0 || $value > 0xFF)
+                                                return false;
+                                }
+                        }
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Checks if the given IP is a valid IPv6 address
+         *
+         * @codeCoverageIgnore
+         * @deprecated Use {@see SimplePie_Net_IPv6::check_ipv6()} instead
+         * @see check_ipv6
+         * @param string $ip An IPv6 address
+         * @return bool true if $ip is a valid IPv6 address
+         */
+        public static function checkIPv6($ip)
+        {
+                return self::check_ipv6($ip);
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Parse/Date.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Parse/Date.php
new file mode 100644
index 00000000..d51f500d
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Parse/Date.php
@@ -0,0 +1,983 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Date Parser
+ *
+ * @package SimplePie
+ * @subpackage Parsing
+ */
+class SimplePie_Parse_Date
+{
+        /**
+         * Input data
+         *
+         * @access protected
+         * @var string
+         */
+        var $date;
+
+        /**
+         * List of days, calendar day name => ordinal day number in the week
+         *
+         * @access protected
+         * @var array
+         */
+        var $day = array(
+                // English
+                'mon' => 1,
+                'monday' => 1,
+                'tue' => 2,
+                'tuesday' => 2,
+                'wed' => 3,
+                'wednesday' => 3,
+                'thu' => 4,
+                'thursday' => 4,
+                'fri' => 5,
+                'friday' => 5,
+                'sat' => 6,
+                'saturday' => 6,
+                'sun' => 7,
+                'sunday' => 7,
+                // Dutch
+                'maandag' => 1,
+                'dinsdag' => 2,
+                'woensdag' => 3,
+                'donderdag' => 4,
+                'vrijdag' => 5,
+                'zaterdag' => 6,
+                'zondag' => 7,
+                // French
+                'lundi' => 1,
+                'mardi' => 2,
+                'mercredi' => 3,
+                'jeudi' => 4,
+                'vendredi' => 5,
+                'samedi' => 6,
+                'dimanche' => 7,
+                // German
+                'montag' => 1,
+                'dienstag' => 2,
+                'mittwoch' => 3,
+                'donnerstag' => 4,
+                'freitag' => 5,
+                'samstag' => 6,
+                'sonnabend' => 6,
+                'sonntag' => 7,
+                // Italian
+                'lunedì' => 1,
+                'martedì' => 2,
+                'mercoledì' => 3,
+                'giovedì' => 4,
+                'venerdì' => 5,
+                'sabato' => 6,
+                'domenica' => 7,
+                // Spanish
+                'lunes' => 1,
+                'martes' => 2,
+                'miércoles' => 3,
+                'jueves' => 4,
+                'viernes' => 5,
+                'sábado' => 6,
+                'domingo' => 7,
+                // Finnish
+                'maanantai' => 1,
+                'tiistai' => 2,
+                'keskiviikko' => 3,
+                'torstai' => 4,
+                'perjantai' => 5,
+                'lauantai' => 6,
+                'sunnuntai' => 7,
+                // Hungarian
+                'hétfő' => 1,
+                'kedd' => 2,
+                'szerda' => 3,
+                'csütörtok' => 4,
+                'péntek' => 5,
+                'szombat' => 6,
+                'vasárnap' => 7,
+                // Greek
+                'Δευ' => 1,
+                'Τρι' => 2,
+                'Τετ' => 3,
+                'Πεμ' => 4,
+                'Παρ' => 5,
+                'Σαβ' => 6,
+                'Κυρ' => 7,
+        );
+
+        /**
+         * List of months, calendar month name => calendar month number
+         *
+         * @access protected
+         * @var array
+         */
+        var $month = array(
+                // English
+                'jan' => 1,
+                'january' => 1,
+                'feb' => 2,
+                'february' => 2,
+                'mar' => 3,
+                'march' => 3,
+                'apr' => 4,
+                'april' => 4,
+                'may' => 5,
+                // No long form of May
+                'jun' => 6,
+                'june' => 6,
+                'jul' => 7,
+                'july' => 7,
+                'aug' => 8,
+                'august' => 8,
+                'sep' => 9,
+                'september' => 8,
+                'oct' => 10,
+                'october' => 10,
+                'nov' => 11,
+                'november' => 11,
+                'dec' => 12,
+                'december' => 12,
+                // Dutch
+                'januari' => 1,
+                'februari' => 2,
+                'maart' => 3,
+                'april' => 4,
+                'mei' => 5,
+                'juni' => 6,
+                'juli' => 7,
+                'augustus' => 8,
+                'september' => 9,
+                'oktober' => 10,
+                'november' => 11,
+                'december' => 12,
+                // French
+                'janvier' => 1,
+                'février' => 2,
+                'mars' => 3,
+                'avril' => 4,
+                'mai' => 5,
+                'juin' => 6,
+                'juillet' => 7,
+                'août' => 8,
+                'septembre' => 9,
+                'octobre' => 10,
+                'novembre' => 11,
+                'décembre' => 12,
+                // German
+                'januar' => 1,
+                'februar' => 2,
+                'märz' => 3,
+                'april' => 4,
+                'mai' => 5,
+                'juni' => 6,
+                'juli' => 7,
+                'august' => 8,
+                'september' => 9,
+                'oktober' => 10,
+                'november' => 11,
+                'dezember' => 12,
+                // Italian
+                'gennaio' => 1,
+                'febbraio' => 2,
+                'marzo' => 3,
+                'aprile' => 4,
+                'maggio' => 5,
+                'giugno' => 6,
+                'luglio' => 7,
+                'agosto' => 8,
+                'settembre' => 9,
+                'ottobre' => 10,
+                'novembre' => 11,
+                'dicembre' => 12,
+                // Spanish
+                'enero' => 1,
+                'febrero' => 2,
+                'marzo' => 3,
+                'abril' => 4,
+                'mayo' => 5,
+                'junio' => 6,
+                'julio' => 7,
+                'agosto' => 8,
+                'septiembre' => 9,
+                'setiembre' => 9,
+                'octubre' => 10,
+                'noviembre' => 11,
+                'diciembre' => 12,
+                // Finnish
+                'tammikuu' => 1,
+                'helmikuu' => 2,
+                'maaliskuu' => 3,
+                'huhtikuu' => 4,
+                'toukokuu' => 5,
+                'kesäkuu' => 6,
+                'heinäkuu' => 7,
+                'elokuu' => 8,
+                'suuskuu' => 9,
+                'lokakuu' => 10,
+                'marras' => 11,
+                'joulukuu' => 12,
+                // Hungarian
+                'január' => 1,
+                'február' => 2,
+                'március' => 3,
+                'április' => 4,
+                'május' => 5,
+                'június' => 6,
+                'július' => 7,
+                'augusztus' => 8,
+                'szeptember' => 9,
+                'október' => 10,
+                'november' => 11,
+                'december' => 12,
+                // Greek
+                'Ιαν' => 1,
+                'Φεβ' => 2,
+                'Μάώ' => 3,
+                'Μαώ' => 3,
+                'Απρ' => 4,
+                'Μάι' => 5,
+                'Μαϊ' => 5,
+                'Μαι' => 5,
+                'Ιούν' => 6,
+                'Ιον' => 6,
+                'Ιούλ' => 7,
+                'Ιολ' => 7,
+                'Αύγ' => 8,
+                'Αυγ' => 8,
+                'Σεπ' => 9,
+                'Οκτ' => 10,
+                'Νοέ' => 11,
+                'Δεκ' => 12,
+        );
+
+        /**
+         * List of timezones, abbreviation => offset from UTC
+         *
+         * @access protected
+         * @var array
+         */
+        var $timezone = array(
+                'ACDT' => 37800,
+                'ACIT' => 28800,
+                'ACST' => 34200,
+                'ACT' => -18000,
+                'ACWDT' => 35100,
+                'ACWST' => 31500,
+                'AEDT' => 39600,
+                'AEST' => 36000,
+                'AFT' => 16200,
+                'AKDT' => -28800,
+                'AKST' => -32400,
+                'AMDT' => 18000,
+                'AMT' => -14400,
+                'ANAST' => 46800,
+                'ANAT' => 43200,
+                'ART' => -10800,
+                'AZOST' => -3600,
+                'AZST' => 18000,
+                'AZT' => 14400,
+                'BIOT' => 21600,
+                'BIT' => -43200,
+                'BOT' => -14400,
+                'BRST' => -7200,
+                'BRT' => -10800,
+                'BST' => 3600,
+                'BTT' => 21600,
+                'CAST' => 18000,
+                'CAT' => 7200,
+                'CCT' => 23400,
+                'CDT' => -18000,
+                'CEDT' => 7200,
+                'CET' => 3600,
+                'CGST' => -7200,
+                'CGT' => -10800,
+                'CHADT' => 49500,
+                'CHAST' => 45900,
+                'CIST' => -28800,
+                'CKT' => -36000,
+                'CLDT' => -10800,
+                'CLST' => -14400,
+                'COT' => -18000,
+                'CST' => -21600,
+                'CVT' => -3600,
+                'CXT' => 25200,
+                'DAVT' => 25200,
+                'DTAT' => 36000,
+                'EADT' => -18000,
+                'EAST' => -21600,
+                'EAT' => 10800,
+                'ECT' => -18000,
+                'EDT' => -14400,
+                'EEST' => 10800,
+                'EET' => 7200,
+                'EGT' => -3600,
+                'EKST' => 21600,
+                'EST' => -18000,
+                'FJT' => 43200,
+                'FKDT' => -10800,
+                'FKST' => -14400,
+                'FNT' => -7200,
+                'GALT' => -21600,
+                'GEDT' => 14400,
+                'GEST' => 10800,
+                'GFT' => -10800,
+                'GILT' => 43200,
+                'GIT' => -32400,
+                'GST' => 14400,
+                'GST' => -7200,
+                'GYT' => -14400,
+                'HAA' => -10800,
+                'HAC' => -18000,
+                'HADT' => -32400,
+                'HAE' => -14400,
+                'HAP' => -25200,
+                'HAR' => -21600,
+                'HAST' => -36000,
+                'HAT' => -9000,
+                'HAY' => -28800,
+                'HKST' => 28800,
+                'HMT' => 18000,
+                'HNA' => -14400,
+                'HNC' => -21600,
+                'HNE' => -18000,
+                'HNP' => -28800,
+                'HNR' => -25200,
+                'HNT' => -12600,
+                'HNY' => -32400,
+                'IRDT' => 16200,
+                'IRKST' => 32400,
+                'IRKT' => 28800,
+                'IRST' => 12600,
+                'JFDT' => -10800,
+                'JFST' => -14400,
+                'JST' => 32400,
+                'KGST' => 21600,
+                'KGT' => 18000,
+                'KOST' => 39600,
+                'KOVST' => 28800,
+                'KOVT' => 25200,
+                'KRAST' => 28800,
+                'KRAT' => 25200,
+                'KST' => 32400,
+                'LHDT' => 39600,
+                'LHST' => 37800,
+                'LINT' => 50400,
+                'LKT' => 21600,
+                'MAGST' => 43200,
+                'MAGT' => 39600,
+                'MAWT' => 21600,
+                'MDT' => -21600,
+                'MESZ' => 7200,
+                'MEZ' => 3600,
+                'MHT' => 43200,
+                'MIT' => -34200,
+                'MNST' => 32400,
+                'MSDT' => 14400,
+                'MSST' => 10800,
+                'MST' => -25200,
+                'MUT' => 14400,
+                'MVT' => 18000,
+                'MYT' => 28800,
+                'NCT' => 39600,
+                'NDT' => -9000,
+                'NFT' => 41400,
+                'NMIT' => 36000,
+                'NOVST' => 25200,
+                'NOVT' => 21600,
+                'NPT' => 20700,
+                'NRT' => 43200,
+                'NST' => -12600,
+                'NUT' => -39600,
+                'NZDT' => 46800,
+                'NZST' => 43200,
+                'OMSST' => 25200,
+                'OMST' => 21600,
+                'PDT' => -25200,
+                'PET' => -18000,
+                'PETST' => 46800,
+                'PETT' => 43200,
+                'PGT' => 36000,
+                'PHOT' => 46800,
+                'PHT' => 28800,
+                'PKT' => 18000,
+                'PMDT' => -7200,
+                'PMST' => -10800,
+                'PONT' => 39600,
+                'PST' => -28800,
+                'PWT' => 32400,
+                'PYST' => -10800,
+                'PYT' => -14400,
+                'RET' => 14400,
+                'ROTT' => -10800,
+                'SAMST' => 18000,
+                'SAMT' => 14400,
+                'SAST' => 7200,
+                'SBT' => 39600,
+                'SCDT' => 46800,
+                'SCST' => 43200,
+                'SCT' => 14400,
+                'SEST' => 3600,
+                'SGT' => 28800,
+                'SIT' => 28800,
+                'SRT' => -10800,
+                'SST' => -39600,
+                'SYST' => 10800,
+                'SYT' => 7200,
+                'TFT' => 18000,
+                'THAT' => -36000,
+                'TJT' => 18000,
+                'TKT' => -36000,
+                'TMT' => 18000,
+                'TOT' => 46800,
+                'TPT' => 32400,
+                'TRUT' => 36000,
+                'TVT' => 43200,
+                'TWT' => 28800,
+                'UYST' => -7200,
+                'UYT' => -10800,
+                'UZT' => 18000,
+                'VET' => -14400,
+                'VLAST' => 39600,
+                'VLAT' => 36000,
+                'VOST' => 21600,
+                'VUT' => 39600,
+                'WAST' => 7200,
+                'WAT' => 3600,
+                'WDT' => 32400,
+                'WEST' => 3600,
+                'WFT' => 43200,
+                'WIB' => 25200,
+                'WIT' => 32400,
+                'WITA' => 28800,
+                'WKST' => 18000,
+                'WST' => 28800,
+                'YAKST' => 36000,
+                'YAKT' => 32400,
+                'YAPT' => 36000,
+                'YEKST' => 21600,
+                'YEKT' => 18000,
+        );
+
+        /**
+         * Cached PCRE for SimplePie_Parse_Date::$day
+         *
+         * @access protected
+         * @var string
+         */
+        var $day_pcre;
+
+        /**
+         * Cached PCRE for SimplePie_Parse_Date::$month
+         *
+         * @access protected
+         * @var string
+         */
+        var $month_pcre;
+
+        /**
+         * Array of user-added callback methods
+         *
+         * @access private
+         * @var array
+         */
+        var $built_in = array();
+
+        /**
+         * Array of user-added callback methods
+         *
+         * @access private
+         * @var array
+         */
+        var $user = array();
+
+        /**
+         * Create new SimplePie_Parse_Date object, and set self::day_pcre,
+         * self::month_pcre, and self::built_in
+         *
+         * @access private
+         */
+        public function __construct()
+        {
+                $this->day_pcre = '(' . implode(array_keys($this->day), '|') . ')';
+                $this->month_pcre = '(' . implode(array_keys($this->month), '|') . ')';
+
+                static $cache;
+                if (!isset($cache[get_class($this)]))
+                {
+                        $all_methods = get_class_methods($this);
+
+                        foreach ($all_methods as $method)
+                        {
+                                if (strtolower(substr($method, 0, 5)) === 'date_')
+                                {
+                                        $cache[get_class($this)][] = $method;
+                                }
+                        }
+                }
+
+                foreach ($cache[get_class($this)] as $method)
+                {
+                        $this->built_in[] = $method;
+                }
+        }
+
+        /**
+         * Get the object
+         *
+         * @access public
+         */
+        public static function get()
+        {
+                static $object;
+                if (!$object)
+                {
+                        $object = new SimplePie_Parse_Date;
+                }
+                return $object;
+        }
+
+        /**
+         * Parse a date
+         *
+         * @final
+         * @access public
+         * @param string $date Date to parse
+         * @return int Timestamp corresponding to date string, or false on failure
+         */
+        public function parse($date)
+        {
+                foreach ($this->user as $method)
+                {
+                        if (($returned = call_user_func($method, $date)) !== false)
+                        {
+                                return $returned;
+                        }
+                }
+
+                foreach ($this->built_in as $method)
+                {
+                        if (($returned = call_user_func(array($this, $method), $date)) !== false)
+                        {
+                                return $returned;
+                        }
+                }
+
+                return false;
+        }
+
+        /**
+         * Add a callback method to parse a date
+         *
+         * @final
+         * @access public
+         * @param callback $callback
+         */
+        public function add_callback($callback)
+        {
+                if (is_callable($callback))
+                {
+                        $this->user[] = $callback;
+                }
+                else
+                {
+                        trigger_error('User-supplied function must be a valid callback', E_USER_WARNING);
+                }
+        }
+
+        /**
+         * Parse a superset of W3C-DTF (allows hyphens and colons to be omitted, as
+         * well as allowing any of upper or lower case "T", horizontal tabs, or
+         * spaces to be used as the time seperator (including more than one))
+         *
+         * @access protected
+         * @return int Timestamp
+         */
+        public function date_w3cdtf($date)
+        {
+                static $pcre;
+                if (!$pcre)
+                {
+                        $year = '([0-9]{4})';
+                        $month = $day = $hour = $minute = $second = '([0-9]{2})';
+                        $decimal = '([0-9]*)';
+                        $zone = '(?:(Z)|([+\-])([0-9]{1,2}):?([0-9]{1,2}))';
+                        $pcre = '/^' . $year . '(?:-?' . $month . '(?:-?' . $day . '(?:[Tt\x09\x20]+' . $hour . '(?::?' . $minute . '(?::?' . $second . '(?:.' . $decimal . ')?)?)?' . $zone . ')?)?)?$/';
+                }
+                if (preg_match($pcre, $date, $match))
+                {
+                        /*
+                        Capturing subpatterns:
+                        1: Year
+                        2: Month
+                        3: Day
+                        4: Hour
+                        5: Minute
+                        6: Second
+                        7: Decimal fraction of a second
+                        8: Zulu
+                        9: Timezone ±
+                        10: Timezone hours
+                        11: Timezone minutes
+                        */
+
+                        // Fill in empty matches
+                        for ($i = count($match); $i <= 3; $i++)
+                        {
+                                $match[$i] = '1';
+                        }
+
+                        for ($i = count($match); $i <= 7; $i++)
+                        {
+                                $match[$i] = '0';
+                        }
+
+                        // Numeric timezone
+                        if (isset($match[9]) && $match[9] !== '')
+                        {
+                                $timezone = $match[10] * 3600;
+                                $timezone += $match[11] * 60;
+                                if ($match[9] === '-')
+                                {
+                                        $timezone = 0 - $timezone;
+                                }
+                        }
+                        else
+                        {
+                                $timezone = 0;
+                        }
+
+                        // Convert the number of seconds to an integer, taking decimals into account
+                        $second = round($match[6] + $match[7] / pow(10, strlen($match[7])));
+
+                        return gmmktime($match[4], $match[5], $second, $match[2], $match[3], $match[1]) - $timezone;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Remove RFC822 comments
+         *
+         * @access protected
+         * @param string $data Data to strip comments from
+         * @return string Comment stripped string
+         */
+        public function remove_rfc2822_comments($string)
+        {
+                $string = (string) $string;
+                $position = 0;
+                $length = strlen($string);
+                $depth = 0;
+
+                $output = '';
+
+                while ($position < $length && ($pos = strpos($string, '(', $position)) !== false)
+                {
+                        $output .= substr($string, $position, $pos - $position);
+                        $position = $pos + 1;
+                        if ($string[$pos - 1] !== '\\')
+                        {
+                                $depth++;
+                                while ($depth && $position < $length)
+                                {
+                                        $position += strcspn($string, '()', $position);
+                                        if ($string[$position - 1] === '\\')
+                                        {
+                                                $position++;
+                                                continue;
+                                        }
+                                        elseif (isset($string[$position]))
+                                        {
+                                                switch ($string[$position])
+                                                {
+                                                        case '(':
+                                                                $depth++;
+                                                                break;
+
+                                                        case ')':
+                                                                $depth--;
+                                                                break;
+                                                }
+                                                $position++;
+                                        }
+                                        else
+                                        {
+                                                break;
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                $output .= '(';
+                        }
+                }
+                $output .= substr($string, $position);
+
+                return $output;
+        }
+
+        /**
+         * Parse RFC2822's date format
+         *
+         * @access protected
+         * @return int Timestamp
+         */
+        public function date_rfc2822($date)
+        {
+                static $pcre;
+                if (!$pcre)
+                {
+                        $wsp = '[\x09\x20]';
+                        $fws = '(?:' . $wsp . '+|' . $wsp . '*(?:\x0D\x0A' . $wsp . '+)+)';
+                        $optional_fws = $fws . '?';
+                        $day_name = $this->day_pcre;
+                        $month = $this->month_pcre;
+                        $day = '([0-9]{1,2})';
+                        $hour = $minute = $second = '([0-9]{2})';
+                        $year = '([0-9]{2,4})';
+                        $num_zone = '([+\-])([0-9]{2})([0-9]{2})';
+                        $character_zone = '([A-Z]{1,5})';
+                        $zone = '(?:' . $num_zone . '|' . $character_zone . ')';
+                        $pcre = '/(?:' . $optional_fws . $day_name . $optional_fws . ',)?' . $optional_fws . $day . $fws . $month . $fws . $year . $fws . $hour . $optional_fws . ':' . $optional_fws . $minute . '(?:' . $optional_fws . ':' . $optional_fws . $second . ')?' . $fws . $zone . '/i';
+                }
+                if (preg_match($pcre, $this->remove_rfc2822_comments($date), $match))
+                {
+                        /*
+                        Capturing subpatterns:
+                        1: Day name
+                        2: Day
+                        3: Month
+                        4: Year
+                        5: Hour
+                        6: Minute
+                        7: Second
+                        8: Timezone ±
+                        9: Timezone hours
+                        10: Timezone minutes
+                        11: Alphabetic timezone
+                        */
+
+                        // Find the month number
+                        $month = $this->month[strtolower($match[3])];
+
+                        // Numeric timezone
+                        if ($match[8] !== '')
+                        {
+                                $timezone = $match[9] * 3600;
+                                $timezone += $match[10] * 60;
+                                if ($match[8] === '-')
+                                {
+                                        $timezone = 0 - $timezone;
+                                }
+                        }
+                        // Character timezone
+                        elseif (isset($this->timezone[strtoupper($match[11])]))
+                        {
+                                $timezone = $this->timezone[strtoupper($match[11])];
+                        }
+                        // Assume everything else to be -0000
+                        else
+                        {
+                                $timezone = 0;
+                        }
+
+                        // Deal with 2/3 digit years
+                        if ($match[4] < 50)
+                        {
+                                $match[4] += 2000;
+                        }
+                        elseif ($match[4] < 1000)
+                        {
+                                $match[4] += 1900;
+                        }
+
+                        // Second is optional, if it is empty set it to zero
+                        if ($match[7] !== '')
+                        {
+                                $second = $match[7];
+                        }
+                        else
+                        {
+                                $second = 0;
+                        }
+
+                        return gmmktime($match[5], $match[6], $second, $month, $match[2], $match[4]) - $timezone;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Parse RFC850's date format
+         *
+         * @access protected
+         * @return int Timestamp
+         */
+        public function date_rfc850($date)
+        {
+                static $pcre;
+                if (!$pcre)
+                {
+                        $space = '[\x09\x20]+';
+                        $day_name = $this->day_pcre;
+                        $month = $this->month_pcre;
+                        $day = '([0-9]{1,2})';
+                        $year = $hour = $minute = $second = '([0-9]{2})';
+                        $zone = '([A-Z]{1,5})';
+                        $pcre = '/^' . $day_name . ',' . $space . $day . '-' . $month . '-' . $year . $space . $hour . ':' . $minute . ':' . $second . $space . $zone . '$/i';
+                }
+                if (preg_match($pcre, $date, $match))
+                {
+                        /*
+                        Capturing subpatterns:
+                        1: Day name
+                        2: Day
+                        3: Month
+                        4: Year
+                        5: Hour
+                        6: Minute
+                        7: Second
+                        8: Timezone
+                        */
+
+                        // Month
+                        $month = $this->month[strtolower($match[3])];
+
+                        // Character timezone
+                        if (isset($this->timezone[strtoupper($match[8])]))
+                        {
+                                $timezone = $this->timezone[strtoupper($match[8])];
+                        }
+                        // Assume everything else to be -0000
+                        else
+                        {
+                                $timezone = 0;
+                        }
+
+                        // Deal with 2 digit year
+                        if ($match[4] < 50)
+                        {
+                                $match[4] += 2000;
+                        }
+                        else
+                        {
+                                $match[4] += 1900;
+                        }
+
+                        return gmmktime($match[5], $match[6], $match[7], $month, $match[2], $match[4]) - $timezone;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Parse C99's asctime()'s date format
+         *
+         * @access protected
+         * @return int Timestamp
+         */
+        public function date_asctime($date)
+        {
+                static $pcre;
+                if (!$pcre)
+                {
+                        $space = '[\x09\x20]+';
+                        $wday_name = $this->day_pcre;
+                        $mon_name = $this->month_pcre;
+                        $day = '([0-9]{1,2})';
+                        $hour = $sec = $min = '([0-9]{2})';
+                        $year = '([0-9]{4})';
+                        $terminator = '\x0A?\x00?';
+                        $pcre = '/^' . $wday_name . $space . $mon_name . $space . $day . $space . $hour . ':' . $min . ':' . $sec . $space . $year . $terminator . '$/i';
+                }
+                if (preg_match($pcre, $date, $match))
+                {
+                        /*
+                        Capturing subpatterns:
+                        1: Day name
+                        2: Month
+                        3: Day
+                        4: Hour
+                        5: Minute
+                        6: Second
+                        7: Year
+                        */
+
+                        $month = $this->month[strtolower($match[2])];
+                        return gmmktime($match[4], $match[5], $match[6], $month, $match[3], $match[7]);
+                }
+                else
+                {
+                        return false;
+                }
+        }
+
+        /**
+         * Parse dates using strtotime()
+         *
+         * @access protected
+         * @return int Timestamp
+         */
+        public function date_strtotime($date)
+        {
+                $strtotime = strtotime($date);
+                if ($strtotime === -1 || $strtotime === false)
+                {
+                        return false;
+                }
+                else
+                {
+                        return $strtotime;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Parser.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Parser.php
new file mode 100644
index 00000000..d698552c
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Parser.php
@@ -0,0 +1,407 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Parses XML into something sane
+ *
+ *
+ * This class can be overloaded with {@see SimplePie::set_parser_class()}
+ *
+ * @package SimplePie
+ * @subpackage Parsing
+ */
+class SimplePie_Parser
+{
+        var $error_code;
+        var $error_string;
+        var $current_line;
+        var $current_column;
+        var $current_byte;
+        var $separator = ' ';
+        var $namespace = array('');
+        var $element = array('');
+        var $xml_base = array('');
+        var $xml_base_explicit = array(false);
+        var $xml_lang = array('');
+        var $data = array();
+        var $datas = array(array());
+        var $current_xhtml_construct = -1;
+        var $encoding;
+        protected $registry;
+
+        public function set_registry(SimplePie_Registry $registry)
+        {
+                $this->registry = $registry;
+        }
+
+        public function parse(&$data, $encoding)
+        {
+                // Use UTF-8 if we get passed US-ASCII, as every US-ASCII character is a UTF-8 character
+                if (strtoupper($encoding) === 'US-ASCII')
+                {
+                        $this->encoding = 'UTF-8';
+                }
+                else
+                {
+                        $this->encoding = $encoding;
+                }
+
+                // Strip BOM:
+                // UTF-32 Big Endian BOM
+                if (substr($data, 0, 4) === "\x00\x00\xFE\xFF")
+                {
+                        $data = substr($data, 4);
+                }
+                // UTF-32 Little Endian BOM
+                elseif (substr($data, 0, 4) === "\xFF\xFE\x00\x00")
+                {
+                        $data = substr($data, 4);
+                }
+                // UTF-16 Big Endian BOM
+                elseif (substr($data, 0, 2) === "\xFE\xFF")
+                {
+                        $data = substr($data, 2);
+                }
+                // UTF-16 Little Endian BOM
+                elseif (substr($data, 0, 2) === "\xFF\xFE")
+                {
+                        $data = substr($data, 2);
+                }
+                // UTF-8 BOM
+                elseif (substr($data, 0, 3) === "\xEF\xBB\xBF")
+                {
+                        $data = substr($data, 3);
+                }
+
+                if (substr($data, 0, 5) === '<?xml' && strspn(substr($data, 5, 1), "\x09\x0A\x0D\x20") && ($pos = strpos($data, '?>')) !== false)
+                {
+                        $declaration = $this->registry->create('XML_Declaration_Parser', array(substr($data, 5, $pos - 5)));
+                        if ($declaration->parse())
+                        {
+                                $data = substr($data, $pos + 2);
+                                $data = '<?xml version="' . $declaration->version . '" encoding="' . $encoding . '" standalone="' . (($declaration->standalone) ? 'yes' : 'no') . '"?>' . $data;
+                        }
+                        else
+                        {
+                                $this->error_string = 'SimplePie bug! Please report this!';
+                                return false;
+                        }
+                }
+
+                $return = true;
+
+                static $xml_is_sane = null;
+                if ($xml_is_sane === null)
+                {
+                        $parser_check = xml_parser_create();
+                        xml_parse_into_struct($parser_check, '<foo>&amp;</foo>', $values);
+                        xml_parser_free($parser_check);
+                        $xml_is_sane = isset($values[0]['value']);
+                }
+
+                // Create the parser
+                if ($xml_is_sane)
+                {
+                        $xml = xml_parser_create_ns($this->encoding, $this->separator);
+                        xml_parser_set_option($xml, XML_OPTION_SKIP_WHITE, 1);
+                        xml_parser_set_option($xml, XML_OPTION_CASE_FOLDING, 0);
+                        xml_set_object($xml, $this);
+                        xml_set_character_data_handler($xml, 'cdata');
+                        xml_set_element_handler($xml, 'tag_open', 'tag_close');
+
+                        // Parse!
+                        if (!xml_parse($xml, $data, true))
+                        {
+                                $this->error_code = xml_get_error_code($xml);
+                                $this->error_string = xml_error_string($this->error_code);
+                                $return = false;
+                        }
+                        $this->current_line = xml_get_current_line_number($xml);
+                        $this->current_column = xml_get_current_column_number($xml);
+                        $this->current_byte = xml_get_current_byte_index($xml);
+                        xml_parser_free($xml);
+                        return $return;
+                }
+                else
+                {
+                        libxml_clear_errors();
+                        $xml = new XMLReader();
+                        $xml->xml($data);
+                        while (@$xml->read())
+                        {
+                                switch ($xml->nodeType)
+                                {
+
+                                        case constant('XMLReader::END_ELEMENT'):
+                                                if ($xml->namespaceURI !== '')
+                                                {
+                                                        $tagName = $xml->namespaceURI . $this->separator . $xml->localName;
+                                                }
+                                                else
+                                                {
+                                                        $tagName = $xml->localName;
+                                                }
+                                                $this->tag_close(null, $tagName);
+                                                break;
+                                        case constant('XMLReader::ELEMENT'):
+                                                $empty = $xml->isEmptyElement;
+                                                if ($xml->namespaceURI !== '')
+                                                {
+                                                        $tagName = $xml->namespaceURI . $this->separator . $xml->localName;
+                                                }
+                                                else
+                                                {
+                                                        $tagName = $xml->localName;
+                                                }
+                                                $attributes = array();
+                                                while ($xml->moveToNextAttribute())
+                                                {
+                                                        if ($xml->namespaceURI !== '')
+                                                        {
+                                                                $attrName = $xml->namespaceURI . $this->separator . $xml->localName;
+                                                        }
+                                                        else
+                                                        {
+                                                                $attrName = $xml->localName;
+                                                        }
+                                                        $attributes[$attrName] = $xml->value;
+                                                }
+                                                $this->tag_open(null, $tagName, $attributes);
+                                                if ($empty)
+                                                {
+                                                        $this->tag_close(null, $tagName);
+                                                }
+                                                break;
+                                        case constant('XMLReader::TEXT'):
+
+                                        case constant('XMLReader::CDATA'):
+                                                $this->cdata(null, $xml->value);
+                                                break;
+                                }
+                        }
+                        if ($error = libxml_get_last_error())
+                        {
+                                $this->error_code = $error->code;
+                                $this->error_string = $error->message;
+                                $this->current_line = $error->line;
+                                $this->current_column = $error->column;
+                                return false;
+                        }
+                        else
+                        {
+                                return true;
+                        }
+                }
+        }
+
+        public function get_error_code()
+        {
+                return $this->error_code;
+        }
+
+        public function get_error_string()
+        {
+                return $this->error_string;
+        }
+
+        public function get_current_line()
+        {
+                return $this->current_line;
+        }
+
+        public function get_current_column()
+        {
+                return $this->current_column;
+        }
+
+        public function get_current_byte()
+        {
+                return $this->current_byte;
+        }
+
+        public function get_data()
+        {
+                return $this->data;
+        }
+
+        public function tag_open($parser, $tag, $attributes)
+        {
+                list($this->namespace[], $this->element[]) = $this->split_ns($tag);
+
+                $attribs = array();
+                foreach ($attributes as $name => $value)
+                {
+                        list($attrib_namespace, $attribute) = $this->split_ns($name);
+                        $attribs[$attrib_namespace][$attribute] = $value;
+                }
+
+                if (isset($attribs[SIMPLEPIE_NAMESPACE_XML]['base']))
+                {
+                        $base = $this->registry->call('Misc', 'absolutize_url', array($attribs[SIMPLEPIE_NAMESPACE_XML]['base'], end($this->xml_base)));
+                        if ($base !== false)
+                        {
+                                $this->xml_base[] = $base;
+                                $this->xml_base_explicit[] = true;
+                        }
+                }
+                else
+                {
+                        $this->xml_base[] = end($this->xml_base);
+                        $this->xml_base_explicit[] = end($this->xml_base_explicit);
+                }
+
+                if (isset($attribs[SIMPLEPIE_NAMESPACE_XML]['lang']))
+                {
+                        $this->xml_lang[] = $attribs[SIMPLEPIE_NAMESPACE_XML]['lang'];
+                }
+                else
+                {
+                        $this->xml_lang[] = end($this->xml_lang);
+                }
+
+                if ($this->current_xhtml_construct >= 0)
+                {
+                        $this->current_xhtml_construct++;
+                        if (end($this->namespace) === SIMPLEPIE_NAMESPACE_XHTML)
+                        {
+                                $this->data['data'] .= '<' . end($this->element);
+                                if (isset($attribs['']))
+                                {
+                                        foreach ($attribs[''] as $name => $value)
+                                        {
+                                                $this->data['data'] .= ' ' . $name . '="' . htmlspecialchars($value, ENT_COMPAT, $this->encoding) . '"';
+                                        }
+                                }
+                                $this->data['data'] .= '>';
+                        }
+                }
+                else
+                {
+                        $this->datas[] =& $this->data;
+                        $this->data =& $this->data['child'][end($this->namespace)][end($this->element)][];
+                        $this->data = array('data' => '', 'attribs' => $attribs, 'xml_base' => end($this->xml_base), 'xml_base_explicit' => end($this->xml_base_explicit), 'xml_lang' => end($this->xml_lang));
+                        if ((end($this->namespace) === SIMPLEPIE_NAMESPACE_ATOM_03 && in_array(end($this->element), array('title', 'tagline', 'copyright', 'info', 'summary', 'content')) && isset($attribs['']['mode']) && $attribs['']['mode'] === 'xml')
+                        || (end($this->namespace) === SIMPLEPIE_NAMESPACE_ATOM_10 && in_array(end($this->element), array('rights', 'subtitle', 'summary', 'info', 'title', 'content')) && isset($attribs['']['type']) && $attribs['']['type'] === 'xhtml')
+                        || (end($this->namespace) === SIMPLEPIE_NAMESPACE_RSS_20 && in_array(end($this->element), array('title')))
+                        || (end($this->namespace) === SIMPLEPIE_NAMESPACE_RSS_090 && in_array(end($this->element), array('title')))
+                        || (end($this->namespace) === SIMPLEPIE_NAMESPACE_RSS_10 && in_array(end($this->element), array('title'))))
+                        {
+                                $this->current_xhtml_construct = 0;
+                        }
+                }
+        }
+
+        public function cdata($parser, $cdata)
+        {
+                if ($this->current_xhtml_construct >= 0)
+                {
+                        $this->data['data'] .= htmlspecialchars($cdata, ENT_QUOTES, $this->encoding);
+                }
+                else
+                {
+                        $this->data['data'] .= $cdata;
+                }
+        }
+
+        public function tag_close($parser, $tag)
+        {
+                if ($this->current_xhtml_construct >= 0)
+                {
+                        $this->current_xhtml_construct--;
+                        if (end($this->namespace) === SIMPLEPIE_NAMESPACE_XHTML && !in_array(end($this->element), array('area', 'base', 'basefont', 'br', 'col', 'frame', 'hr', 'img', 'input', 'isindex', 'link', 'meta', 'param')))
+                        {
+                                $this->data['data'] .= '</' . end($this->element) . '>';
+                        }
+                }
+                if ($this->current_xhtml_construct === -1)
+                {
+                        $this->data =& $this->datas[count($this->datas) - 1];
+                        array_pop($this->datas);
+                }
+
+                array_pop($this->element);
+                array_pop($this->namespace);
+                array_pop($this->xml_base);
+                array_pop($this->xml_base_explicit);
+                array_pop($this->xml_lang);
+        }
+
+        public function split_ns($string)
+        {
+                static $cache = array();
+                if (!isset($cache[$string]))
+                {
+                        if ($pos = strpos($string, $this->separator))
+                        {
+                                static $separator_length;
+                                if (!$separator_length)
+                                {
+                                        $separator_length = strlen($this->separator);
+                                }
+                                $namespace = substr($string, 0, $pos);
+                                $local_name = substr($string, $pos + $separator_length);
+                                if (strtolower($namespace) === SIMPLEPIE_NAMESPACE_ITUNES)
+                                {
+                                        $namespace = SIMPLEPIE_NAMESPACE_ITUNES;
+                                }
+
+                                // Normalize the Media RSS namespaces
+                                if ($namespace === SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG ||
+                                        $namespace === SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2 ||
+                                        $namespace === SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3 ||
+                                        $namespace === SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4 ||
+                                        $namespace === SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5 )
+                                {
+                                        $namespace = SIMPLEPIE_NAMESPACE_MEDIARSS;
+                                }
+                                $cache[$string] = array($namespace, $local_name);
+                        }
+                        else
+                        {
+                                $cache[$string] = array('', $string);
+                        }
+                }
+                return $cache[$string];
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Rating.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Rating.php
new file mode 100644
index 00000000..8689e5df
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Rating.php
@@ -0,0 +1,129 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles `<media:rating>` or `<itunes:explicit>` tags as defined in Media RSS and iTunes RSS respectively
+ *
+ * Used by {@see SimplePie_Enclosure::get_rating()} and {@see SimplePie_Enclosure::get_ratings()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_rating_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Rating
+{
+        /**
+         * Rating scheme
+         *
+         * @var string
+         * @see get_scheme()
+         */
+        var $scheme;
+
+        /**
+         * Rating value
+         *
+         * @var string
+         * @see get_value()
+         */
+        var $value;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         */
+        public function __construct($scheme = null, $value = null)
+        {
+                $this->scheme = $scheme;
+                $this->value = $value;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the organizational scheme for the rating
+         *
+         * @return string|null
+         */
+        public function get_scheme()
+        {
+                if ($this->scheme !== null)
+                {
+                        return $this->scheme;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the value of the rating
+         *
+         * @return string|null
+         */
+        public function get_value()
+        {
+                if ($this->value !== null)
+                {
+                        return $this->value;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Registry.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Registry.php
new file mode 100644
index 00000000..1072cdeb
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Registry.php
@@ -0,0 +1,225 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles creating objects and calling methods
+ *
+ * Access this via {@see SimplePie::get_registry()}
+ *
+ * @package SimplePie
+ */
+class SimplePie_Registry
+{
+        /**
+         * Default class mapping
+         *
+         * Overriding classes *must* subclass these.
+         *
+         * @var array
+         */
+        protected $default = array(
+                'Cache' => 'SimplePie_Cache',
+                'Locator' => 'SimplePie_Locator',
+                'Parser' => 'SimplePie_Parser',
+                'File' => 'SimplePie_File',
+                'Sanitize' => 'SimplePie_Sanitize',
+                'Item' => 'SimplePie_Item',
+                'Author' => 'SimplePie_Author',
+                'Category' => 'SimplePie_Category',
+                'Enclosure' => 'SimplePie_Enclosure',
+                'Caption' => 'SimplePie_Caption',
+                'Copyright' => 'SimplePie_Copyright',
+                'Credit' => 'SimplePie_Credit',
+                'Rating' => 'SimplePie_Rating',
+                'Restriction' => 'SimplePie_Restriction',
+                'Content_Type_Sniffer' => 'SimplePie_Content_Type_Sniffer',
+                'Source' => 'SimplePie_Source',
+                'Misc' => 'SimplePie_Misc',
+                'XML_Declaration_Parser' => 'SimplePie_XML_Declaration_Parser',
+                'Parse_Date' => 'SimplePie_Parse_Date',
+        );
+
+        /**
+         * Class mapping
+         *
+         * @see register()
+         * @var array
+         */
+        protected $classes = array();
+
+        /**
+         * Legacy classes
+         *
+         * @see register()
+         * @var array
+         */
+        protected $legacy = array();
+
+        /**
+         * Constructor
+         *
+         * No-op
+         */
+        public function __construct() { }
+
+        /**
+         * Register a class
+         *
+         * @param string $type See {@see $default} for names
+         * @param string $class Class name, must subclass the corresponding default
+         * @param bool $legacy Whether to enable legacy support for this class
+         * @return bool Successfulness
+         */
+        public function register($type, $class, $legacy = false)
+        {
+                if (!is_subclass_of($class, $this->default[$type]))
+                {
+                        return false;
+                }
+
+                $this->classes[$type] = $class;
+
+                if ($legacy)
+                {
+                        $this->legacy[] = $class;
+                }
+
+                return true;
+        }
+
+        /**
+         * Get the class registered for a type
+         *
+         * Where possible, use {@see create()} or {@see call()} instead
+         *
+         * @param string $type
+         * @return string|null
+         */
+        public function get_class($type)
+        {
+                if (!empty($this->classes[$type]))
+                {
+                        return $this->classes[$type];
+                }
+                if (!empty($this->default[$type]))
+                {
+                        return $this->default[$type];
+                }
+
+                return null;
+        }
+
+        /**
+         * Create a new instance of a given type
+         *
+         * @param string $type
+         * @param array $parameters Parameters to pass to the constructor
+         * @return object Instance of class
+         */
+        public function &create($type, $parameters = array())
+        {
+                $class = $this->get_class($type);
+
+                if (in_array($class, $this->legacy))
+                {
+                        switch ($type)
+                        {
+                                case 'locator':
+                                        // Legacy: file, timeout, useragent, file_class, max_checked_feeds, content_type_sniffer_class
+                                        // Specified: file, timeout, useragent, max_checked_feeds
+                                        $replacement = array($this->get_class('file'), $parameters[3], $this->get_class('content_type_sniffer'));
+                                        array_splice($parameters, 3, 1, $replacement);
+                                        break;
+                        }
+                }
+
+                if (!method_exists($class, '__construct'))
+                {
+                        $instance = new $class;
+                }
+                else
+                {
+                        $reflector = new ReflectionClass($class);
+                        $instance = $reflector->newInstanceArgs($parameters);
+                }
+
+                if (method_exists($instance, 'set_registry'))
+                {
+                        $instance->set_registry($this);
+                }
+                return $instance;
+        }
+
+        /**
+         * Call a static method for a type
+         *
+         * @param string $type
+         * @param string $method
+         * @param array $parameters
+         * @return mixed
+         */
+        public function &call($type, $method, $parameters = array())
+        {
+                $class = $this->get_class($type);
+
+                if (in_array($class, $this->legacy))
+                {
+                        switch ($type)
+                        {
+                                case 'Cache':
+                                        // For backwards compatibility with old non-static
+                                        // Cache::create() methods
+                                        if ($method === 'get_handler')
+                                        {
+                                                $result = @call_user_func_array(array($class, 'create'), $parameters);
+                                                return $result;
+                                        }
+                                        break;
+                        }
+                }
+
+                $result = call_user_func_array(array($class, $method), $parameters);
+                return $result;
+        }
+}
\ No newline at end of file
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Restriction.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Restriction.php
new file mode 100644
index 00000000..4ba371bf
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Restriction.php
@@ -0,0 +1,155 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles `<media:restriction>` as defined in Media RSS
+ *
+ * Used by {@see SimplePie_Enclosure::get_restriction()} and {@see SimplePie_Enclosure::get_restrictions()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_restriction_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Restriction
+{
+        /**
+         * Relationship ('allow'/'deny')
+         *
+         * @var string
+         * @see get_relationship()
+         */
+        var $relationship;
+
+        /**
+         * Type of restriction
+         *
+         * @var string
+         * @see get_type()
+         */
+        var $type;
+
+        /**
+         * Restricted values
+         *
+         * @var string
+         * @see get_value()
+         */
+        var $value;
+
+        /**
+         * Constructor, used to input the data
+         *
+         * For documentation on all the parameters, see the corresponding
+         * properties and their accessors
+         */
+        public function __construct($relationship = null, $type = null, $value = null)
+        {
+                $this->relationship = $relationship;
+                $this->type = $type;
+                $this->value = $value;
+        }
+
+        /**
+         * String-ified version
+         *
+         * @return string
+         */
+        public function __toString()
+        {
+                // There is no $this->data here
+                return md5(serialize($this));
+        }
+
+        /**
+         * Get the relationship
+         *
+         * @return string|null Either 'allow' or 'deny'
+         */
+        public function get_relationship()
+        {
+                if ($this->relationship !== null)
+                {
+                        return $this->relationship;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the type
+         *
+         * @return string|null
+         */
+        public function get_type()
+        {
+                if ($this->type !== null)
+                {
+                        return $this->type;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Get the list of restricted things
+         *
+         * @return string|null
+         */
+        public function get_value()
+        {
+                if ($this->value !== null)
+                {
+                        return $this->value;
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Sanitize.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Sanitize.php
new file mode 100644
index 00000000..6810cc49
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Sanitize.php
@@ -0,0 +1,549 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Used for data cleanup and post-processing
+ *
+ *
+ * This class can be overloaded with {@see SimplePie::set_sanitize_class()}
+ *
+ * @package SimplePie
+ * @todo Move to using an actual HTML parser (this will allow tags to be properly stripped, and to switch between HTML and XHTML), this will also make it easier to shorten a string while preserving HTML tags
+ */
+class SimplePie_Sanitize
+{
+        // Private vars
+        var $base;
+
+        // Options
+        var $remove_div = true;
+        var $image_handler = '';
+        var $strip_htmltags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style');
+        var $encode_instead_of_strip = false;
+        var $strip_attributes = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc');
+        var $strip_comments = false;
+        var $output_encoding = 'UTF-8';
+        var $enable_cache = true;
+        var $cache_location = './cache';
+        var $cache_name_function = 'md5';
+        var $timeout = 10;
+        var $useragent = '';
+        var $force_fsockopen = false;
+        var $replace_url_attributes = null;
+
+        public function __construct()
+        {
+                // Set defaults
+                $this->set_url_replacements(null);
+        }
+
+        public function remove_div($enable = true)
+        {
+                $this->remove_div = (bool) $enable;
+        }
+
+        public function set_image_handler($page = false)
+        {
+                if ($page)
+                {
+                        $this->image_handler = (string) $page;
+                }
+                else
+                {
+                        $this->image_handler = false;
+                }
+        }
+
+        public function set_registry(SimplePie_Registry $registry)
+        {
+                $this->registry = $registry;
+        }
+
+        public function pass_cache_data($enable_cache = true, $cache_location = './cache', $cache_name_function = 'md5', $cache_class = 'SimplePie_Cache')
+        {
+                if (isset($enable_cache))
+                {
+                        $this->enable_cache = (bool) $enable_cache;
+                }
+
+                if ($cache_location)
+                {
+                        $this->cache_location = (string) $cache_location;
+                }
+
+                if ($cache_name_function)
+                {
+                        $this->cache_name_function = (string) $cache_name_function;
+                }
+        }
+
+        public function pass_file_data($file_class = 'SimplePie_File', $timeout = 10, $useragent = '', $force_fsockopen = false)
+        {
+                if ($timeout)
+                {
+                        $this->timeout = (string) $timeout;
+                }
+
+                if ($useragent)
+                {
+                        $this->useragent = (string) $useragent;
+                }
+
+                if ($force_fsockopen)
+                {
+                        $this->force_fsockopen = (string) $force_fsockopen;
+                }
+        }
+
+        public function strip_htmltags($tags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style'))
+        {
+                if ($tags)
+                {
+                        if (is_array($tags))
+                        {
+                                $this->strip_htmltags = $tags;
+                        }
+                        else
+                        {
+                                $this->strip_htmltags = explode(',', $tags);
+                        }
+                }
+                else
+                {
+                        $this->strip_htmltags = false;
+                }
+        }
+
+        public function encode_instead_of_strip($encode = false)
+        {
+                $this->encode_instead_of_strip = (bool) $encode;
+        }
+
+        public function strip_attributes($attribs = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc'))
+        {
+                if ($attribs)
+                {
+                        if (is_array($attribs))
+                        {
+                                $this->strip_attributes = $attribs;
+                        }
+                        else
+                        {
+                                $this->strip_attributes = explode(',', $attribs);
+                        }
+                }
+                else
+                {
+                        $this->strip_attributes = false;
+                }
+        }
+
+        public function strip_comments($strip = false)
+        {
+                $this->strip_comments = (bool) $strip;
+        }
+
+        public function set_output_encoding($encoding = 'UTF-8')
+        {
+                $this->output_encoding = (string) $encoding;
+        }
+
+        /**
+         * Set element/attribute key/value pairs of HTML attributes
+         * containing URLs that need to be resolved relative to the feed
+         *
+         * Defaults to |a|@href, |area|@href, |blockquote|@cite, |del|@cite,
+         * |form|@action, |img|@longdesc, |img|@src, |input|@src, |ins|@cite,
+         * |q|@cite
+         *
+         * @since 1.0
+         * @param array|null $element_attribute Element/attribute key/value pairs, null for default
+         */
+        public function set_url_replacements($element_attribute = null)
+        {
+                if ($element_attribute === null)
+                {
+                        $element_attribute = array(
+                                'a' => 'href',
+                                'area' => 'href',
+                                'blockquote' => 'cite',
+                                'del' => 'cite',
+                                'form' => 'action',
+                                'img' => array(
+                                        'longdesc',
+                                        'src'
+                                ),
+                                'input' => 'src',
+                                'ins' => 'cite',
+                                'q' => 'cite'
+                        );
+                }
+                $this->replace_url_attributes = (array) $element_attribute;
+        }
+
+        public function sanitize($data, $type, $base = '')
+        {
+                $data = trim($data);
+                if ($data !== '' || $type & SIMPLEPIE_CONSTRUCT_IRI)
+                {
+                        if ($type & SIMPLEPIE_CONSTRUCT_MAYBE_HTML)
+                        {
+                                if (preg_match('/(&(#(x[0-9a-fA-F]+|[0-9]+)|[a-zA-Z0-9]+)|<\/[A-Za-z][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E]*' . SIMPLEPIE_PCRE_HTML_ATTRIBUTE . '>)/', $data))
+                                {
+                                        $type |= SIMPLEPIE_CONSTRUCT_HTML;
+                                }
+                                else
+                                {
+                                        $type |= SIMPLEPIE_CONSTRUCT_TEXT;
+                                }
+                        }
+
+                        if ($type & SIMPLEPIE_CONSTRUCT_BASE64)
+                        {
+                                $data = base64_decode($data);
+                        }
+
+                        if ($type & (SIMPLEPIE_CONSTRUCT_HTML | SIMPLEPIE_CONSTRUCT_XHTML))
+                        {
+
+                                $document = new DOMDocument();
+                                $document->encoding = 'UTF-8';
+                                $data = $this->preprocess($data, $type);
+
+                                set_error_handler(array('SimplePie_Misc', 'silence_errors'));
+                                $document->loadHTML($data);
+                                restore_error_handler();
+
+                                // Strip comments
+                                if ($this->strip_comments)
+                                {
+                                        $xpath = new DOMXPath($document);
+                                        $comments = $xpath->query('//comment()');
+
+                                        foreach ($comments as $comment)
+                                        {
+                                                $comment->parentNode->removeChild($comment);
+                                        }
+                                }
+
+                                // Strip out HTML tags and attributes that might cause various security problems.
+                                // Based on recommendations by Mark Pilgrim at:
+                                // http://diveintomark.org/archives/2003/06/12/how_to_consume_rss_safely
+                                if ($this->strip_htmltags)
+                                {
+                                        foreach ($this->strip_htmltags as $tag)
+                                        {
+                                                $this->strip_tag($tag, $document, $type);
+                                        }
+                                }
+
+                                if ($this->strip_attributes)
+                                {
+                                        foreach ($this->strip_attributes as $attrib)
+                                        {
+                                                $this->strip_attr($attrib, $document);
+                                        }
+                                }
+
+                                // Replace relative URLs
+                                $this->base = $base;
+                                foreach ($this->replace_url_attributes as $element => $attributes)
+                                {
+                                        $this->replace_urls($document, $element, $attributes);
+                                }
+
+                                // If image handling (caching, etc.) is enabled, cache and rewrite all the image tags.
+                                if (isset($this->image_handler) && ((string) $this->image_handler) !== '' && $this->enable_cache)
+                                {
+                                        $images = $document->getElementsByTagName('img');
+                                        foreach ($images as $img)
+                                        {
+                                                if ($img->hasAttribute('src'))
+                                                {
+                                                        $image_url = call_user_func($this->cache_name_function, $img->getAttribute('src'));
+                                                        $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, $image_url, 'spi'));
+
+                                                        if ($cache->load())
+                                                        {
+                                                                $img->setAttribute('src', $this->image_handler . $image_url);
+                                                        }
+                                                        else
+                                                        {
+                                                                $file = $this->registry->create('File', array($img['attribs']['src']['data'], $this->timeout, 5, array('X-FORWARDED-FOR' => $_SERVER['REMOTE_ADDR']), $this->useragent, $this->force_fsockopen));
+                                                                $headers = $file->headers;
+
+                                                                if ($file->success && ($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($file->status_code === 200 || $file->status_code > 206 && $file->status_code < 300)))
+                                                                {
+                                                                        if ($cache->save(array('headers' => $file->headers, 'body' => $file->body)))
+                                                                        {
+                                                                                $img->setAttribute('src', $this->image_handler . $image_url);
+                                                                        }
+                                                                        else
+                                                                        {
+                                                                                trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING);
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                }
+
+                                // Remove the DOCTYPE
+                                // Seems to cause segfaulting if we don't do this
+                                if ($document->firstChild instanceof DOMDocumentType)
+                                {
+                                        $document->removeChild($document->firstChild);
+                                }
+
+                                // Move everything from the body to the root
+                                $real_body = $document->getElementsByTagName('body')->item(0)->childNodes->item(0);
+                                $document->replaceChild($real_body, $document->firstChild);
+
+                                // Finally, convert to a HTML string
+                                $data = trim($document->saveHTML());
+
+                                if ($this->remove_div)
+                                {
+                                        $data = preg_replace('/^<div' . SIMPLEPIE_PCRE_XML_ATTRIBUTE . '>/', '', $data);
+                                        $data = preg_replace('/<\/div>$/', '', $data);
+                                }
+                                else
+                                {
+                                        $data = preg_replace('/^<div' . SIMPLEPIE_PCRE_XML_ATTRIBUTE . '>/', '<div>', $data);
+                                }
+                        }
+
+                        if ($type & SIMPLEPIE_CONSTRUCT_IRI)
+                        {
+                                $absolute = $this->registry->call('Misc', 'absolutize_url', array($data, $base));
+                                if ($absolute !== false)
+                                {
+                                        $data = $absolute;
+                                }
+                        }
+
+                        if ($type & (SIMPLEPIE_CONSTRUCT_TEXT | SIMPLEPIE_CONSTRUCT_IRI))
+                        {
+                                $data = htmlspecialchars($data, ENT_COMPAT, 'UTF-8');
+                        }
+
+                        if ($this->output_encoding !== 'UTF-8')
+                        {
+                                $data = $this->registry->call('Misc', 'change_encoding', array($data, 'UTF-8', $this->output_encoding));
+                        }
+                }
+                return $data;
+        }
+
+        protected function preprocess($html, $type)
+        {
+                $ret = '';
+                if ($type & ~SIMPLEPIE_CONSTRUCT_XHTML)
+                {
+                        // Atom XHTML constructs are wrapped with a div by default
+                        // Note: No protection if $html contains a stray </div>!
+                        $html = '<div>' . $html . '</div>';
+                        $ret .= '<!DOCTYPE html>';
+                        $content_type = 'text/html';
+                }
+                else
+                {
+                        $ret .= '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">';
+                        $content_type = 'application/xhtml+xml';
+                }
+
+                $ret .= '<html><head>';
+                $ret .= '<meta http-equiv="Content-Type" content="' . $content_type . '; charset=utf-8" />';
+                $ret .= '</head><body>' . $html . '</body></html>';
+                return $ret;
+        }
+
+        public function replace_urls($document, $tag, $attributes)
+        {
+                if (!is_array($attributes))
+                {
+                        $attributes = array($attributes);
+                }
+
+                if (!is_array($this->strip_htmltags) || !in_array($tag, $this->strip_htmltags))
+                {
+                        $elements = $document->getElementsByTagName($tag);
+                        foreach ($elements as $element)
+                        {
+                                foreach ($attributes as $attribute)
+                                {
+                                        if ($element->hasAttribute($attribute))
+                                        {
+                                                $value = $this->registry->call('Misc', 'absolutize_url', array($element->getAttribute($attribute), $this->base));
+                                                if ($value !== false)
+                                                {
+                                                        $element->setAttribute($attribute, $value);
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        public function do_strip_htmltags($match)
+        {
+                if ($this->encode_instead_of_strip)
+                {
+                        if (isset($match[4]) && !in_array(strtolower($match[1]), array('script', 'style')))
+                        {
+                                $match[1] = htmlspecialchars($match[1], ENT_COMPAT, 'UTF-8');
+                                $match[2] = htmlspecialchars($match[2], ENT_COMPAT, 'UTF-8');
+                                return "&lt;$match[1]$match[2]&gt;$match[3]&lt;/$match[1]&gt;";
+                        }
+                        else
+                        {
+                                return htmlspecialchars($match[0], ENT_COMPAT, 'UTF-8');
+                        }
+                }
+                elseif (isset($match[4]) && !in_array(strtolower($match[1]), array('script', 'style')))
+                {
+                        return $match[4];
+                }
+                else
+                {
+                        return '';
+                }
+        }
+
+        protected function strip_tag($tag, $document, $type)
+        {
+                $xpath = new DOMXPath($document);
+                $elements = $xpath->query('body//' . $tag);
+                if ($this->encode_instead_of_strip)
+                {
+                        foreach ($elements as $element)
+                        {
+                                $fragment = $document->createDocumentFragment();
+
+                                // For elements which aren't script or style, include the tag itself
+                                if (!in_array($tag, array('script', 'style')))
+                                {
+                                        $text = '<' . $tag;
+                                        if ($element->hasAttributes())
+                                        {
+                                                $attrs = array();
+                                                foreach ($element->attributes as $name => $attr)
+                                                {
+                                                        $value = $attr->value;
+
+                                                        // In XHTML, empty values should never exist, so we repeat the value
+                                                        if (empty($value) && ($type & SIMPLEPIE_CONSTRUCT_XHTML))
+                                                        {
+                                                                $value = $name;
+                                                        }
+                                                        // For HTML, empty is fine
+                                                        elseif (empty($value) && ($type & SIMPLEPIE_CONSTRUCT_HTML))
+                                                        {
+                                                                $attrs[] = $name;
+                                                                continue;
+                                                        }
+
+                                                        // Standard attribute text
+                                                        $attrs[] = $name . '="' . $attr->value . '"';
+                                                }
+                                                $text .= ' ' . implode(' ', $attrs);
+                                        }
+                                        $text .= '>';
+                                        $fragment->appendChild(new DOMText($text));
+                                }
+
+                                $number = $element->childNodes->length;
+                                for ($i = $number; $i > 0; $i--)
+                                {
+                                        $child = $element->childNodes->item(0);
+                                        $fragment->appendChild($child);
+                                }
+
+                                if (!in_array($tag, array('script', 'style')))
+                                {
+                                        $fragment->appendChild(new DOMText('</' . $tag . '>'));
+                                }
+
+                                $element->parentNode->replaceChild($fragment, $element);
+                        }
+
+                        return;
+                }
+                elseif (in_array($tag, array('script', 'style')))
+                {
+                        foreach ($elements as $element)
+                        {
+                                $element->parentNode->removeChild($element);
+                        }
+
+                        return;
+                }
+                else
+                {
+                        foreach ($elements as $element)
+                        {
+                                $fragment = $document->createDocumentFragment();
+                                $number = $element->childNodes->length;
+                                for ($i = $number; $i > 0; $i--)
+                                {
+                                        $child = $element->childNodes->item(0);
+                                        $fragment->appendChild($child);
+                                }
+
+                                $element->parentNode->replaceChild($fragment, $element);
+                        }
+                }
+        }
+
+        protected function strip_attr($attrib, $document)
+        {
+                $xpath = new DOMXPath($document);
+                $elements = $xpath->query('//*[@' . $attrib . ']');
+
+                foreach ($elements as $element)
+                {
+                        $element->removeAttribute($attrib);
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/Source.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/Source.php
new file mode 100644
index 00000000..51d8e6c2
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/Source.php
@@ -0,0 +1,611 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+/**
+ * Handles `<atom:source>`
+ *
+ * Used by {@see SimplePie_Item::get_source()}
+ *
+ * This class can be overloaded with {@see SimplePie::set_source_class()}
+ *
+ * @package SimplePie
+ * @subpackage API
+ */
+class SimplePie_Source
+{
+        var $item;
+        var $data = array();
+        protected $registry;
+
+        public function __construct($item, $data)
+        {
+                $this->item = $item;
+                $this->data = $data;
+        }
+
+        public function set_registry(SimplePie_Registry $registry)
+        {
+                $this->registry = $registry;
+        }
+
+        public function __toString()
+        {
+                return md5(serialize($this->data));
+        }
+
+        public function get_source_tags($namespace, $tag)
+        {
+                if (isset($this->data['child'][$namespace][$tag]))
+                {
+                        return $this->data['child'][$namespace][$tag];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_base($element = array())
+        {
+                return $this->item->get_base($element);
+        }
+
+        public function sanitize($data, $type, $base = '')
+        {
+                return $this->item->sanitize($data, $type, $base);
+        }
+
+        public function get_item()
+        {
+                return $this->item;
+        }
+
+        public function get_title()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_category($key = 0)
+        {
+                $categories = $this->get_categories();
+                if (isset($categories[$key]))
+                {
+                        return $categories[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_categories()
+        {
+                $categories = array();
+
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category)
+                {
+                        $term = null;
+                        $scheme = null;
+                        $label = null;
+                        if (isset($category['attribs']['']['term']))
+                        {
+                                $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['scheme']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($category['attribs']['']['label']))
+                        {
+                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category)
+                {
+                        // This is really the label, but keep this as the term also for BC.
+                        // Label will also work on retrieving because that falls back to term.
+                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        if (isset($category['attribs']['']['domain']))
+                        {
+                                $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        else
+                        {
+                                $scheme = null;
+                        }
+                        $categories[] = $this->registry->create('Category', array($term, $scheme, null));
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category)
+                {
+                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($categories))
+                {
+                        return array_unique($categories);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_author($key = 0)
+        {
+                $authors = $this->get_authors();
+                if (isset($authors[$key]))
+                {
+                        return $authors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_authors()
+        {
+                $authors = array();
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                if ($author = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $authors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
+                {
+                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
+                }
+
+                if (!empty($authors))
+                {
+                        return array_unique($authors);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_contributor($key = 0)
+        {
+                $contributors = $this->get_contributors();
+                if (isset($contributors[$key]))
+                {
+                        return $contributors[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_contributors()
+        {
+                $contributors = array();
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $uri = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
+                        {
+                                $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $uri !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $uri, $email));
+                        }
+                }
+                foreach ((array) $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor)
+                {
+                        $name = null;
+                        $url = null;
+                        $email = null;
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
+                        {
+                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
+                        {
+                                $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
+                        }
+                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
+                        {
+                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                        }
+                        if ($name !== null || $email !== null || $url !== null)
+                        {
+                                $contributors[] = $this->registry->create('Author', array($name, $url, $email));
+                        }
+                }
+
+                if (!empty($contributors))
+                {
+                        return array_unique($contributors);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_link($key = 0, $rel = 'alternate')
+        {
+                $links = $this->get_links($rel);
+                if (isset($links[$key]))
+                {
+                        return $links[$key];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        /**
+         * Added for parity between the parent-level and the item/entry-level.
+         */
+        public function get_permalink()
+        {
+                return $this->get_link(0);
+        }
+
+        public function get_links($rel = 'alternate')
+        {
+                if (!isset($this->data['links']))
+                {
+                        $this->data['links'] = array();
+                        if ($links = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link'))
+                        {
+                                foreach ($links as $link)
+                                {
+                                        if (isset($link['attribs']['']['href']))
+                                        {
+                                                $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                                $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+                                        }
+                                }
+                        }
+                        if ($links = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link'))
+                        {
+                                foreach ($links as $link)
+                                {
+                                        if (isset($link['attribs']['']['href']))
+                                        {
+                                                $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
+                                                $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
+
+                                        }
+                                }
+                        }
+                        if ($links = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+                        if ($links = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
+                        {
+                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
+                        }
+
+                        $keys = array_keys($this->data['links']);
+                        foreach ($keys as $key)
+                        {
+                                if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key)))
+                                {
+                                        if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]))
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]);
+                                                $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key];
+                                        }
+                                        else
+                                        {
+                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key];
+                                        }
+                                }
+                                elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY)
+                                {
+                                        $this->data['links'][substr($key, 41)] =& $this->data['links'][$key];
+                                }
+                                $this->data['links'][$key] = array_unique($this->data['links'][$key]);
+                        }
+                }
+
+                if (isset($this->data['links'][$rel]))
+                {
+                        return $this->data['links'][$rel];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_description()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'subtitle'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'tagline'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_copyright()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'copyright'))
+                {
+                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'copyright'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_language()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_11, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_DC_10, 'language'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                elseif (isset($this->data['xml_lang']))
+                {
+                        return $this->sanitize($this->data['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT);
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_latitude()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[1];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_longitude()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon'))
+                {
+                        return (float) $return[0]['data'];
+                }
+                elseif (($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
+                {
+                        return (float) $match[2];
+                }
+                else
+                {
+                        return null;
+                }
+        }
+
+        public function get_image_url()
+        {
+                if ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'image'))
+                {
+                        return $this->sanitize($return[0]['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI);
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'logo'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                elseif ($return = $this->get_source_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'icon'))
+                {
+                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0]));
+                }
+                else
+                {
+                        return null;
+                }
+        }
+}
+
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/XML/Declaration/Parser.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/XML/Declaration/Parser.php
new file mode 100644
index 00000000..aec19f10
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/XML/Declaration/Parser.php
@@ -0,0 +1,362 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Parses the XML Declaration
+ *
+ * @package SimplePie
+ * @subpackage Parsing
+ */
+class SimplePie_XML_Declaration_Parser
+{
+        /**
+         * XML Version
+         *
+         * @access public
+         * @var string
+         */
+        var $version = '1.0';
+
+        /**
+         * Encoding
+         *
+         * @access public
+         * @var string
+         */
+        var $encoding = 'UTF-8';
+
+        /**
+         * Standalone
+         *
+         * @access public
+         * @var bool
+         */
+        var $standalone = false;
+
+        /**
+         * Current state of the state machine
+         *
+         * @access private
+         * @var string
+         */
+        var $state = 'before_version_name';
+
+        /**
+         * Input data
+         *
+         * @access private
+         * @var string
+         */
+        var $data = '';
+
+        /**
+         * Input data length (to avoid calling strlen() everytime this is needed)
+         *
+         * @access private
+         * @var int
+         */
+        var $data_length = 0;
+
+        /**
+         * Current position of the pointer
+         *
+         * @var int
+         * @access private
+         */
+        var $position = 0;
+
+        /**
+         * Create an instance of the class with the input data
+         *
+         * @access public
+         * @param string $data Input data
+         */
+        public function __construct($data)
+        {
+                $this->data = $data;
+                $this->data_length = strlen($this->data);
+        }
+
+        /**
+         * Parse the input data
+         *
+         * @access public
+         * @return bool true on success, false on failure
+         */
+        public function parse()
+        {
+                while ($this->state && $this->state !== 'emit' && $this->has_data())
+                {
+                        $state = $this->state;
+                        $this->$state();
+                }
+                $this->data = '';
+                if ($this->state === 'emit')
+                {
+                        return true;
+                }
+                else
+                {
+                        $this->version = '';
+                        $this->encoding = '';
+                        $this->standalone = '';
+                        return false;
+                }
+        }
+
+        /**
+         * Check whether there is data beyond the pointer
+         *
+         * @access private
+         * @return bool true if there is further data, false if not
+         */
+        public function has_data()
+        {
+                return (bool) ($this->position < $this->data_length);
+        }
+
+        /**
+         * Advance past any whitespace
+         *
+         * @return int Number of whitespace characters passed
+         */
+        public function skip_whitespace()
+        {
+                $whitespace = strspn($this->data, "\x09\x0A\x0D\x20", $this->position);
+                $this->position += $whitespace;
+                return $whitespace;
+        }
+
+        /**
+         * Read value
+         */
+        public function get_value()
+        {
+                $quote = substr($this->data, $this->position, 1);
+                if ($quote === '"' || $quote === "'")
+                {
+                        $this->position++;
+                        $len = strcspn($this->data, $quote, $this->position);
+                        if ($this->has_data())
+                        {
+                                $value = substr($this->data, $this->position, $len);
+                                $this->position += $len + 1;
+                                return $value;
+                        }
+                }
+                return false;
+        }
+
+        public function before_version_name()
+        {
+                if ($this->skip_whitespace())
+                {
+                        $this->state = 'version_name';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function version_name()
+        {
+                if (substr($this->data, $this->position, 7) === 'version')
+                {
+                        $this->position += 7;
+                        $this->skip_whitespace();
+                        $this->state = 'version_equals';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function version_equals()
+        {
+                if (substr($this->data, $this->position, 1) === '=')
+                {
+                        $this->position++;
+                        $this->skip_whitespace();
+                        $this->state = 'version_value';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function version_value()
+        {
+                if ($this->version = $this->get_value())
+                {
+                        $this->skip_whitespace();
+                        if ($this->has_data())
+                        {
+                                $this->state = 'encoding_name';
+                        }
+                        else
+                        {
+                                $this->state = 'emit';
+                        }
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function encoding_name()
+        {
+                if (substr($this->data, $this->position, 8) === 'encoding')
+                {
+                        $this->position += 8;
+                        $this->skip_whitespace();
+                        $this->state = 'encoding_equals';
+                }
+                else
+                {
+                        $this->state = 'standalone_name';
+                }
+        }
+
+        public function encoding_equals()
+        {
+                if (substr($this->data, $this->position, 1) === '=')
+                {
+                        $this->position++;
+                        $this->skip_whitespace();
+                        $this->state = 'encoding_value';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function encoding_value()
+        {
+                if ($this->encoding = $this->get_value())
+                {
+                        $this->skip_whitespace();
+                        if ($this->has_data())
+                        {
+                                $this->state = 'standalone_name';
+                        }
+                        else
+                        {
+                                $this->state = 'emit';
+                        }
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function standalone_name()
+        {
+                if (substr($this->data, $this->position, 10) === 'standalone')
+                {
+                        $this->position += 10;
+                        $this->skip_whitespace();
+                        $this->state = 'standalone_equals';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function standalone_equals()
+        {
+                if (substr($this->data, $this->position, 1) === '=')
+                {
+                        $this->position++;
+                        $this->skip_whitespace();
+                        $this->state = 'standalone_value';
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+
+        public function standalone_value()
+        {
+                if ($standalone = $this->get_value())
+                {
+                        switch ($standalone)
+                        {
+                                case 'yes':
+                                        $this->standalone = true;
+                                        break;
+
+                                case 'no':
+                                        $this->standalone = false;
+                                        break;
+
+                                default:
+                                        $this->state = false;
+                                        return;
+                        }
+
+                        $this->skip_whitespace();
+                        if ($this->has_data())
+                        {
+                                $this->state = false;
+                        }
+                        else
+                        {
+                                $this->state = 'emit';
+                        }
+                }
+                else
+                {
+                        $this->state = false;
+                }
+        }
+}
diff --git a/inc/3rdparty/libraries/simplepie/library/SimplePie/gzdecode.php b/inc/3rdparty/libraries/simplepie/library/SimplePie/gzdecode.php
new file mode 100644
index 00000000..52e024ea
--- /dev/null
+++ b/inc/3rdparty/libraries/simplepie/library/SimplePie/gzdecode.php
@@ -0,0 +1,371 @@
+<?php
+/**
+ * SimplePie
+ *
+ * A PHP-Based RSS and Atom Feed Framework.
+ * Takes the hard work out of managing a complete RSS/Atom solution.
+ *
+ * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *      * Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
+ *        to endorse or promote products derived from this software without specific prior
+ *        written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+ * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package SimplePie
+ * @version 1.3.1
+ * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
+ * @author Ryan Parman
+ * @author Geoffrey Sneddon
+ * @author Ryan McCue
+ * @link http://simplepie.org/ SimplePie
+ * @license http://www.opensource.org/licenses/bsd-license.php BSD License
+ */
+
+
+/**
+ * Decode 'gzip' encoded HTTP data
+ *
+ * @package SimplePie
+ * @subpackage HTTP
+ * @link http://www.gzip.org/format.txt
+ */
+class SimplePie_gzdecode
+{
+        /**
+         * Compressed data
+         *
+         * @access private
+         * @var string
+         * @see gzdecode::$data
+         */
+        var $compressed_data;
+
+        /**
+         * Size of compressed data
+         *
+         * @access private
+         * @var int
+         */
+        var $compressed_size;
+
+        /**
+         * Minimum size of a valid gzip string
+         *
+         * @access private
+         * @var int
+         */
+        var $min_compressed_size = 18;
+
+        /**
+         * Current position of pointer
+         *
+         * @access private
+         * @var int
+         */
+        var $position = 0;
+
+        /**
+         * Flags (FLG)
+         *
+         * @access private
+         * @var int
+         */
+        var $flags;
+
+        /**
+         * Uncompressed data
+         *
+         * @access public
+         * @see gzdecode::$compressed_data
+         * @var string
+         */
+        var $data;
+
+        /**
+         * Modified time
+         *
+         * @access public
+         * @var int
+         */
+        var $MTIME;
+
+        /**
+         * Extra Flags
+         *
+         * @access public
+         * @var int
+         */
+        var $XFL;
+
+        /**
+         * Operating System
+         *
+         * @access public
+         * @var int
+         */
+        var $OS;
+
+        /**
+         * Subfield ID 1
+         *
+         * @access public
+         * @see gzdecode::$extra_field
+         * @see gzdecode::$SI2
+         * @var string
+         */
+        var $SI1;
+
+        /**
+         * Subfield ID 2
+         *
+         * @access public
+         * @see gzdecode::$extra_field
+         * @see gzdecode::$SI1
+         * @var string
+         */
+        var $SI2;
+
+        /**
+         * Extra field content
+         *
+         * @access public
+         * @see gzdecode::$SI1
+         * @see gzdecode::$SI2
+         * @var string
+         */
+        var $extra_field;
+
+        /**
+         * Original filename
+         *
+         * @access public
+         * @var string
+         */
+        var $filename;
+
+        /**
+         * Human readable comment
+         *
+         * @access public
+         * @var string
+         */
+        var $comment;
+
+        /**
+         * Don't allow anything to be set
+         *
+         * @param string $name
+         * @param mixed $value
+         */
+        public function __set($name, $value)
+        {
+                trigger_error("Cannot write property $name", E_USER_ERROR);
+        }
+
+        /**
+         * Set the compressed string and related properties
+         *
+         * @param string $data
+         */
+        public function __construct($data)
+        {
+                $this->compressed_data = $data;
+                $this->compressed_size = strlen($data);
+        }
+
+        /**
+         * Decode the GZIP stream
+         *
+         * @return bool Successfulness
+         */
+        public function parse()
+        {
+                if ($this->compressed_size >= $this->min_compressed_size)
+                {
+                        // Check ID1, ID2, and CM
+                        if (substr($this->compressed_data, 0, 3) !== "\x1F\x8B\x08")
+                        {
+                                return false;
+                        }
+
+                        // Get the FLG (FLaGs)
+                        $this->flags = ord($this->compressed_data[3]);
+
+                        // FLG bits above (1 << 4) are reserved
+                        if ($this->flags > 0x1F)
+                        {
+                                return false;
+                        }
+
+                        // Advance the pointer after the above
+                        $this->position += 4;
+
+                        // MTIME
+                        $mtime = substr($this->compressed_data, $this->position, 4);
+                        // Reverse the string if we're on a big-endian arch because l is the only signed long and is machine endianness
+                        if (current(unpack('S', "\x00\x01")) === 1)
+                        {
+                                $mtime = strrev($mtime);
+                        }
+                        $this->MTIME = current(unpack('l', $mtime));
+                        $this->position += 4;
+
+                        // Get the XFL (eXtra FLags)
+                        $this->XFL = ord($this->compressed_data[$this->position++]);
+
+                        // Get the OS (Operating System)
+                        $this->OS = ord($this->compressed_data[$this->position++]);
+
+                        // Parse the FEXTRA
+                        if ($this->flags & 4)
+                        {
+                                // Read subfield IDs
+                                $this->SI1 = $this->compressed_data[$this->position++];
+                                $this->SI2 = $this->compressed_data[$this->position++];
+
+                                // SI2 set to zero is reserved for future use
+                                if ($this->SI2 === "\x00")
+                                {
+                                        return false;
+                                }
+
+                                // Get the length of the extra field
+                                $len = current(unpack('v', substr($this->compressed_data, $this->position, 2)));
+                                $this->position += 2;
+
+                                // Check the length of the string is still valid
+                                $this->min_compressed_size += $len + 4;
+                                if ($this->compressed_size >= $this->min_compressed_size)
+                                {
+                                        // Set the extra field to the given data
+                                        $this->extra_field = substr($this->compressed_data, $this->position, $len);
+                                        $this->position += $len;
+                                }
+                                else
+                                {
+                                        return false;
+                                }
+                        }
+
+                        // Parse the FNAME
+                        if ($this->flags & 8)
+                        {
+                                // Get the length of the filename
+                                $len = strcspn($this->compressed_data, "\x00", $this->position);
+
+                                // Check the length of the string is still valid
+                                $this->min_compressed_size += $len + 1;
+                                if ($this->compressed_size >= $this->min_compressed_size)
+                                {
+                                        // Set the original filename to the given string
+                                        $this->filename = substr($this->compressed_data, $this->position, $len);
+                                        $this->position += $len + 1;
+                                }
+                                else
+                                {
+                                        return false;
+                                }
+                        }
+
+                        // Parse the FCOMMENT
+                        if ($this->flags & 16)
+                        {
+                                // Get the length of the comment
+                                $len = strcspn($this->compressed_data, "\x00", $this->position);
+
+                                // Check the length of the string is still valid
+                                $this->min_compressed_size += $len + 1;
+                                if ($this->compressed_size >= $this->min_compressed_size)
+                                {
+                                        // Set the original comment to the given string
+                                        $this->comment = substr($this->compressed_data, $this->position, $len);
+                                        $this->position += $len + 1;
+                                }
+                                else
+                                {
+                                        return false;
+                                }
+                        }
+
+                        // Parse the FHCRC
+                        if ($this->flags & 2)
+                        {
+                                // Check the length of the string is still valid
+                                $this->min_compressed_size += $len + 2;
+                                if ($this->compressed_size >= $this->min_compressed_size)
+                                {
+                                        // Read the CRC
+                                        $crc = current(unpack('v', substr($this->compressed_data, $this->position, 2)));
+
+                                        // Check the CRC matches
+                                        if ((crc32(substr($this->compressed_data, 0, $this->position)) & 0xFFFF) === $crc)
+                                        {
+                                                $this->position += 2;
+                                        }
+                                        else
+                                        {
+                                                return false;
+                                        }
+                                }
+                                else
+                                {
+                                        return false;
+                                }
+                        }
+
+                        // Decompress the actual data
+                        if (($this->data = gzinflate(substr($this->compressed_data, $this->position, -8))) === false)
+                        {
+                                return false;
+                        }
+                        else
+                        {
+                                $this->position = $this->compressed_size - 8;
+                        }
+
+                        // Check CRC of data
+                        $crc = current(unpack('V', substr($this->compressed_data, $this->position, 4)));
+                        $this->position += 4;
+                        /*if (extension_loaded('hash') && sprintf('%u', current(unpack('V', hash('crc32b', $this->data)))) !== sprintf('%u', $crc))
+                        {
+                                return false;
+                        }*/
+
+                        // Check ISIZE of data
+                        $isize = current(unpack('V', substr($this->compressed_data, $this->position, 4)));
+                        $this->position += 4;
+                        if (sprintf('%u', strlen($this->data) & 0xFFFFFFFF) !== sprintf('%u', $isize))
+                        {
+                                return false;
+                        }
+
+                        // Wow, against all odds, we've actually got a valid gzip string
+                        return true;
+                }
+                else
+                {
+                        return false;
+                }
+        }
+}