﻿PK      �U�Zb���  �    streams.phpnu W+A��        <?php
/**
 * Classes, which help reading streams of data from files.
 * Based on the classes from Danilo Segan <danilo@kvota.net>
 *
 * @version $Id: streams.php 1157 2015-11-20 04:30:11Z dd32 $
 * @package pomo
 * @subpackage streams
 */

if ( ! class_exists( 'POMO_Reader', false ) ) :
	#[AllowDynamicProperties]
	class POMO_Reader {

		public $endian = 'little';
		public $_pos;
		public $is_overloaded;

		/**
		 * PHP5 constructor.
		 */
		public function __construct() {
			if ( function_exists( 'mb_substr' )
				&& ( (int) ini_get( 'mbstring.func_overload' ) & 2 ) // phpcs:ignore PHPCompatibility.IniDirectives.RemovedIniDirectives.mbstring_func_overloadDeprecated
			) {
				$this->is_overloaded = true;
			} else {
				$this->is_overloaded = false;
			}

			$this->_pos = 0;
		}

		/**
		 * PHP4 constructor.
		 *
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see POMO_Reader::__construct()
		 */
		public function POMO_Reader() {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct();
		}

		/**
		 * Sets the endianness of the file.
		 *
		 * @param string $endian Set the endianness of the file. Accepts 'big', or 'little'.
		 */
		public function setEndian( $endian ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
			$this->endian = $endian;
		}

		/**
		 * Reads a 32bit Integer from the Stream
		 *
		 * @return mixed The integer, corresponding to the next 32 bits from
		 *  the stream of false if there are not enough bytes or on error
		 */
		public function readint32() {
			$bytes = $this->read( 4 );
			if ( 4 !== $this->strlen( $bytes ) ) {
				return false;
			}
			$endian_letter = ( 'big' === $this->endian ) ? 'N' : 'V';
			$int           = unpack( $endian_letter, $bytes );
			return reset( $int );
		}

		/**
		 * Reads an array of 32-bit Integers from the Stream
		 *
		 * @param int $count How many elements should be read
		 * @return mixed Array of integers or false if there isn't
		 *  enough data or on error
		 */
		public function readint32array( $count ) {
			$bytes = $this->read( 4 * $count );
			if ( 4 * $count !== $this->strlen( $bytes ) ) {
				return false;
			}
			$endian_letter = ( 'big' === $this->endian ) ? 'N' : 'V';
			return unpack( $endian_letter . $count, $bytes );
		}

		/**
		 * @param string $input_string
		 * @param int    $start
		 * @param int    $length
		 * @return string
		 */
		public function substr( $input_string, $start, $length ) {
			if ( $this->is_overloaded ) {
				return mb_substr( $input_string, $start, $length, 'ascii' );
			} else {
				return substr( $input_string, $start, $length );
			}
		}

		/**
		 * @param string $input_string
		 * @return int
		 */
		public function strlen( $input_string ) {
			if ( $this->is_overloaded ) {
				return mb_strlen( $input_string, 'ascii' );
			} else {
				return strlen( $input_string );
			}
		}

		/**
		 * @param string $input_string
		 * @param int    $chunk_size
		 * @return array
		 */
		public function str_split( $input_string, $chunk_size ) {
			if ( ! function_exists( 'str_split' ) ) {
				$length = $this->strlen( $input_string );
				$out    = array();
				for ( $i = 0; $i < $length; $i += $chunk_size ) {
					$out[] = $this->substr( $input_string, $i, $chunk_size );
				}
				return $out;
			} else {
				return str_split( $input_string, $chunk_size );
			}
		}

		/**
		 * @return int
		 */
		public function pos() {
			return $this->_pos;
		}

		/**
		 * @return true
		 */
		public function is_resource() {
			return true;
		}

		/**
		 * @return true
		 */
		public function close() {
			return true;
		}
	}
endif;

if ( ! class_exists( 'POMO_FileReader', false ) ) :
	class POMO_FileReader extends POMO_Reader {

		/**
		 * File pointer resource.
		 *
		 * @var resource|false
		 */
		public $_f;

		/**
		 * @param string $filename
		 */
		public function __construct( $filename ) {
			parent::__construct();
			$this->_f = fopen( $filename, 'rb' );
		}

		/**
		 * PHP4 constructor.
		 *
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see POMO_FileReader::__construct()
		 */
		public function POMO_FileReader( $filename ) {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct( $filename );
		}

		/**
		 * @param int $bytes
		 * @return string|false Returns read string, otherwise false.
		 */
		public function read( $bytes ) {
			return fread( $this->_f, $bytes );
		}

		/**
		 * @param int $pos
		 * @return bool
		 */
		public function seekto( $pos ) {
			if ( -1 === fseek( $this->_f, $pos, SEEK_SET ) ) {
				return false;
			}
			$this->_pos = $pos;
			return true;
		}

		/**
		 * @return bool
		 */
		public function is_resource() {
			return is_resource( $this->_f );
		}

		/**
		 * @return bool
		 */
		public function feof() {
			return feof( $this->_f );
		}

		/**
		 * @return bool
		 */
		public function close() {
			return fclose( $this->_f );
		}

		/**
		 * @return string
		 */
		public function read_all() {
			return stream_get_contents( $this->_f );
		}
	}
endif;

if ( ! class_exists( 'POMO_StringReader', false ) ) :
	/**
	 * Provides file-like methods for manipulating a string instead
	 * of a physical file.
	 */
	class POMO_StringReader extends POMO_Reader {

		public $_str = '';

		/**
		 * PHP5 constructor.
		 */
		public function __construct( $str = '' ) {
			parent::__construct();
			$this->_str = $str;
			$this->_pos = 0;
		}

		/**
		 * PHP4 constructor.
		 *
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see POMO_StringReader::__construct()
		 */
		public function POMO_StringReader( $str = '' ) {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct( $str );
		}

		/**
		 * @param string $bytes
		 * @return string
		 */
		public function read( $bytes ) {
			$data        = $this->substr( $this->_str, $this->_pos, $bytes );
			$this->_pos += $bytes;
			if ( $this->strlen( $this->_str ) < $this->_pos ) {
				$this->_pos = $this->strlen( $this->_str );
			}
			return $data;
		}

		/**
		 * @param int $pos
		 * @return int
		 */
		public function seekto( $pos ) {
			$this->_pos = $pos;
			if ( $this->strlen( $this->_str ) < $this->_pos ) {
				$this->_pos = $this->strlen( $this->_str );
			}
			return $this->_pos;
		}

		/**
		 * @return int
		 */
		public function length() {
			return $this->strlen( $this->_str );
		}

		/**
		 * @return string
		 */
		public function read_all() {
			return $this->substr( $this->_str, $this->_pos, $this->strlen( $this->_str ) );
		}
	}
endif;

if ( ! class_exists( 'POMO_CachedFileReader', false ) ) :
	/**
	 * Reads the contents of the file in the beginning.
	 */
	class POMO_CachedFileReader extends POMO_StringReader {
		/**
		 * PHP5 constructor.
		 */
		public function __construct( $filename ) {
			parent::__construct();
			$this->_str = file_get_contents( $filename );
			if ( false === $this->_str ) {
				return false;
			}
			$this->_pos = 0;
		}

		/**
		 * PHP4 constructor.
		 *
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see POMO_CachedFileReader::__construct()
		 */
		public function POMO_CachedFileReader( $filename ) {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct( $filename );
		}
	}
endif;

if ( ! class_exists( 'POMO_CachedIntFileReader', false ) ) :
	/**
	 * Reads the contents of the file in the beginning.
	 */
	class POMO_CachedIntFileReader extends POMO_CachedFileReader {
		/**
		 * PHP5 constructor.
		 */
		public function __construct( $filename ) {
			parent::__construct( $filename );
		}

		/**
		 * PHP4 constructor.
		 *
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see POMO_CachedIntFileReader::__construct()
		 */
		public function POMO_CachedIntFileReader( $filename ) {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct( $filename );
		}
	}
endif;
PK      �U�Z�<\C%  C%    mo.phpnu W+A��        <?php
/**
 * Class for working with MO files
 *
 * @version $Id: mo.php 1157 2015-11-20 04:30:11Z dd32 $
 * @package pomo
 * @subpackage mo
 */

require_once __DIR__ . '/translations.php';
require_once __DIR__ . '/streams.php';

if ( ! class_exists( 'MO', false ) ) :
	class MO extends Gettext_Translations {

		/**
		 * Number of plural forms.
		 *
		 * @var int
		 */
		public $_nplurals = 2;

		/**
		 * Loaded MO file.
		 *
		 * @var string
		 */
		private $filename = '';

		/**
		 * Returns the loaded MO file.
		 *
		 * @return string The loaded MO file.
		 */
		public function get_filename() {
			return $this->filename;
		}

		/**
		 * Fills up with the entries from MO file $filename
		 *
		 * @param string $filename MO file to load
		 * @return bool True if the import from file was successful, otherwise false.
		 */
		public function import_from_file( $filename ) {
			$reader = new POMO_FileReader( $filename );

			if ( ! $reader->is_resource() ) {
				return false;
			}

			$this->filename = (string) $filename;

			return $this->import_from_reader( $reader );
		}

		/**
		 * @param string $filename
		 * @return bool
		 */
		public function export_to_file( $filename ) {
			$fh = fopen( $filename, 'wb' );
			if ( ! $fh ) {
				return false;
			}
			$res = $this->export_to_file_handle( $fh );
			fclose( $fh );
			return $res;
		}

		/**
		 * @return string|false
		 */
		public function export() {
			$tmp_fh = fopen( 'php://temp', 'r+' );
			if ( ! $tmp_fh ) {
				return false;
			}
			$this->export_to_file_handle( $tmp_fh );
			rewind( $tmp_fh );
			return stream_get_contents( $tmp_fh );
		}

		/**
		 * @param Translation_Entry $entry
		 * @return bool
		 */
		public function is_entry_good_for_export( $entry ) {
			if ( empty( $entry->translations ) ) {
				return false;
			}

			if ( ! array_filter( $entry->translations ) ) {
				return false;
			}

			return true;
		}

		/**
		 * @param resource $fh
		 * @return true
		 */
		public function export_to_file_handle( $fh ) {
			$entries = array_filter( $this->entries, array( $this, 'is_entry_good_for_export' ) );
			ksort( $entries );
			$magic                     = 0x950412de;
			$revision                  = 0;
			$total                     = count( $entries ) + 1; // All the headers are one entry.
			$originals_lengths_addr    = 28;
			$translations_lengths_addr = $originals_lengths_addr + 8 * $total;
			$size_of_hash              = 0;
			$hash_addr                 = $translations_lengths_addr + 8 * $total;
			$current_addr              = $hash_addr;
			fwrite(
				$fh,
				pack(
					'V*',
					$magic,
					$revision,
					$total,
					$originals_lengths_addr,
					$translations_lengths_addr,
					$size_of_hash,
					$hash_addr
				)
			);
			fseek( $fh, $originals_lengths_addr );

			// Headers' msgid is an empty string.
			fwrite( $fh, pack( 'VV', 0, $current_addr ) );
			++$current_addr;
			$originals_table = "\0";

			$reader = new POMO_Reader();

			foreach ( $entries as $entry ) {
				$originals_table .= $this->export_original( $entry ) . "\0";
				$length           = $reader->strlen( $this->export_original( $entry ) );
				fwrite( $fh, pack( 'VV', $length, $current_addr ) );
				$current_addr += $length + 1; // Account for the NULL byte after.
			}

			$exported_headers = $this->export_headers();
			fwrite( $fh, pack( 'VV', $reader->strlen( $exported_headers ), $current_addr ) );
			$current_addr      += strlen( $exported_headers ) + 1;
			$translations_table = $exported_headers . "\0";

			foreach ( $entries as $entry ) {
				$translations_table .= $this->export_translations( $entry ) . "\0";
				$length              = $reader->strlen( $this->export_translations( $entry ) );
				fwrite( $fh, pack( 'VV', $length, $current_addr ) );
				$current_addr += $length + 1;
			}

			fwrite( $fh, $originals_table );
			fwrite( $fh, $translations_table );
			return true;
		}

		/**
		 * @param Translation_Entry $entry
		 * @return string
		 */
		public function export_original( $entry ) {
			// TODO: Warnings for control characters.
			$exported = $entry->singular;
			if ( $entry->is_plural ) {
				$exported .= "\0" . $entry->plural;
			}
			if ( $entry->context ) {
				$exported = $entry->context . "\4" . $exported;
			}
			return $exported;
		}

		/**
		 * @param Translation_Entry $entry
		 * @return string
		 */
		public function export_translations( $entry ) {
			// TODO: Warnings for control characters.
			return $entry->is_plural ? implode( "\0", $entry->translations ) : $entry->translations[0];
		}

		/**
		 * @return string
		 */
		public function export_headers() {
			$exported = '';
			foreach ( $this->headers as $header => $value ) {
				$exported .= "$header: $value\n";
			}
			return $exported;
		}

		/**
		 * @param int $magic
		 * @return string|false
		 */
		public function get_byteorder( $magic ) {
			// The magic is 0x950412de.

			// bug in PHP 5.0.2, see https://savannah.nongnu.org/bugs/?func=detailitem&item_id=10565
			$magic_little    = (int) - 1794895138;
			$magic_little_64 = (int) 2500072158;
			// 0xde120495
			$magic_big = ( (int) - 569244523 ) & 0xFFFFFFFF;
			if ( $magic_little === $magic || $magic_little_64 === $magic ) {
				return 'little';
			} elseif ( $magic_big === $magic ) {
				return 'big';
			} else {
				return false;
			}
		}

		/**
		 * @param POMO_FileReader $reader
		 * @return bool True if the import was successful, otherwise false.
		 */
		public function import_from_reader( $reader ) {
			$endian_string = MO::get_byteorder( $reader->readint32() );
			if ( false === $endian_string ) {
				return false;
			}
			$reader->setEndian( $endian_string );

			$endian = ( 'big' === $endian_string ) ? 'N' : 'V';

			$header = $reader->read( 24 );
			if ( $reader->strlen( $header ) !== 24 ) {
				return false;
			}

			// Parse header.
			$header = unpack( "{$endian}revision/{$endian}total/{$endian}originals_lengths_addr/{$endian}translations_lengths_addr/{$endian}hash_length/{$endian}hash_addr", $header );
			if ( ! is_array( $header ) ) {
				return false;
			}

			// Support revision 0 of MO format specs, only.
			if ( 0 !== $header['revision'] ) {
				return false;
			}

			// Seek to data blocks.
			$reader->seekto( $header['originals_lengths_addr'] );

			// Read originals' indices.
			$originals_lengths_length = $header['translations_lengths_addr'] - $header['originals_lengths_addr'];
			if ( $originals_lengths_length !== $header['total'] * 8 ) {
				return false;
			}

			$originals = $reader->read( $originals_lengths_length );
			if ( $reader->strlen( $originals ) !== $originals_lengths_length ) {
				return false;
			}

			// Read translations' indices.
			$translations_lengths_length = $header['hash_addr'] - $header['translations_lengths_addr'];
			if ( $translations_lengths_length !== $header['total'] * 8 ) {
				return false;
			}

			$translations = $reader->read( $translations_lengths_length );
			if ( $reader->strlen( $translations ) !== $translations_lengths_length ) {
				return false;
			}

			// Transform raw data into set of indices.
			$originals    = $reader->str_split( $originals, 8 );
			$translations = $reader->str_split( $translations, 8 );

			// Skip hash table.
			$strings_addr = $header['hash_addr'] + $header['hash_length'] * 4;

			$reader->seekto( $strings_addr );

			$strings = $reader->read_all();
			$reader->close();

			for ( $i = 0; $i < $header['total']; $i++ ) {
				$o = unpack( "{$endian}length/{$endian}pos", $originals[ $i ] );
				$t = unpack( "{$endian}length/{$endian}pos", $translations[ $i ] );
				if ( ! $o || ! $t ) {
					return false;
				}

				// Adjust offset due to reading strings to separate space before.
				$o['pos'] -= $strings_addr;
				$t['pos'] -= $strings_addr;

				$original    = $reader->substr( $strings, $o['pos'], $o['length'] );
				$translation = $reader->substr( $strings, $t['pos'], $t['length'] );

				if ( '' === $original ) {
					$this->set_headers( $this->make_headers( $translation ) );
				} else {
					$entry                          = &$this->make_entry( $original, $translation );
					$this->entries[ $entry->key() ] = &$entry;
				}
			}
			return true;
		}

		/**
		 * Build a Translation_Entry from original string and translation strings,
		 * found in a MO file
		 *
		 * @static
		 * @param string $original original string to translate from MO file. Might contain
		 *  0x04 as context separator or 0x00 as singular/plural separator
		 * @param string $translation translation string from MO file. Might contain
		 *  0x00 as a plural translations separator
		 * @return Translation_Entry Entry instance.
		 */
		public function &make_entry( $original, $translation ) {
			$entry = new Translation_Entry();
			// Look for context, separated by \4.
			$parts = explode( "\4", $original );
			if ( isset( $parts[1] ) ) {
				$original       = $parts[1];
				$entry->context = $parts[0];
			}
			// Look for plural original.
			$parts           = explode( "\0", $original );
			$entry->singular = $parts[0];
			if ( isset( $parts[1] ) ) {
				$entry->is_plural = true;
				$entry->plural    = $parts[1];
			}
			// Plural translations are also separated by \0.
			$entry->translations = explode( "\0", $translation );
			return $entry;
		}

		/**
		 * @param int $count
		 * @return string
		 */
		public function select_plural_form( $count ) {
			return $this->gettext_select_plural_form( $count );
		}

		/**
		 * @return int
		 */
		public function get_plural_forms_count() {
			return $this->_nplurals;
		}
	}
endif;
PK      �U�Z�+��2  2    translations.phpnu W+A��        <?php
/**
 * Class for a set of entries for translation and their associated headers
 *
 * @version $Id: translations.php 1157 2015-11-20 04:30:11Z dd32 $
 * @package pomo
 * @subpackage translations
 * @since 2.8.0
 */

require_once __DIR__ . '/plural-forms.php';
require_once __DIR__ . '/entry.php';

if ( ! class_exists( 'Translations', false ) ) :
	/**
	 * Translations class.
	 *
	 * @since 2.8.0
	 */
	#[AllowDynamicProperties]
	class Translations {
		/**
		 * List of translation entries.
		 *
		 * @since 2.8.0
		 *
		 * @var Translation_Entry[]
		 */
		public $entries = array();

		/**
		 * List of translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @var array<string, string>
		 */
		public $headers = array();

		/**
		 * Adds an entry to the PO structure.
		 *
		 * @since 2.8.0
		 *
		 * @param array|Translation_Entry $entry
		 * @return bool True on success, false if the entry doesn't have a key.
		 */
		public function add_entry( $entry ) {
			if ( is_array( $entry ) ) {
				$entry = new Translation_Entry( $entry );
			}
			$key = $entry->key();
			if ( false === $key ) {
				return false;
			}
			$this->entries[ $key ] = &$entry;
			return true;
		}

		/**
		 * Adds or merges an entry to the PO structure.
		 *
		 * @since 2.8.0
		 *
		 * @param array|Translation_Entry $entry
		 * @return bool True on success, false if the entry doesn't have a key.
		 */
		public function add_entry_or_merge( $entry ) {
			if ( is_array( $entry ) ) {
				$entry = new Translation_Entry( $entry );
			}
			$key = $entry->key();
			if ( false === $key ) {
				return false;
			}
			if ( isset( $this->entries[ $key ] ) ) {
				$this->entries[ $key ]->merge_with( $entry );
			} else {
				$this->entries[ $key ] = &$entry;
			}
			return true;
		}

		/**
		 * Sets $header PO header to $value
		 *
		 * If the header already exists, it will be overwritten
		 *
		 * TODO: this should be out of this class, it is gettext specific
		 *
		 * @since 2.8.0
		 *
		 * @param string $header header name, without trailing :
		 * @param string $value header value, without trailing \n
		 */
		public function set_header( $header, $value ) {
			$this->headers[ $header ] = $value;
		}

		/**
		 * Sets translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @param array $headers Associative array of headers.
		 */
		public function set_headers( $headers ) {
			foreach ( $headers as $header => $value ) {
				$this->set_header( $header, $value );
			}
		}

		/**
		 * Returns a given translation header.
		 *
		 * @since 2.8.0
		 *
		 * @param string $header
		 * @return string|false Header if it exists, false otherwise.
		 */
		public function get_header( $header ) {
			return isset( $this->headers[ $header ] ) ? $this->headers[ $header ] : false;
		}

		/**
		 * Returns a given translation entry.
		 *
		 * @since 2.8.0
		 *
		 * @param Translation_Entry $entry Translation entry.
		 * @return Translation_Entry|false Translation entry if it exists, false otherwise.
		 */
		public function translate_entry( &$entry ) {
			$key = $entry->key();
			return isset( $this->entries[ $key ] ) ? $this->entries[ $key ] : false;
		}

		/**
		 * Translates a singular string.
		 *
		 * @since 2.8.0
		 *
		 * @param string $singular
		 * @param string $context
		 * @return string
		 */
		public function translate( $singular, $context = null ) {
			$entry      = new Translation_Entry(
				array(
					'singular' => $singular,
					'context'  => $context,
				)
			);
			$translated = $this->translate_entry( $entry );
			return ( $translated && ! empty( $translated->translations ) ) ? $translated->translations[0] : $singular;
		}

		/**
		 * Given the number of items, returns the 0-based index of the plural form to use
		 *
		 * Here, in the base Translations class, the common logic for English is implemented:
		 *  0 if there is one element, 1 otherwise
		 *
		 * This function should be overridden by the subclasses. For example MO/PO can derive the logic
		 * from their headers.
		 *
		 * @since 2.8.0
		 *
		 * @param int $count Number of items.
		 * @return int Plural form to use.
		 */
		public function select_plural_form( $count ) {
			return 1 === (int) $count ? 0 : 1;
		}

		/**
		 * Returns the plural forms count.
		 *
		 * @since 2.8.0
		 *
		 * @return int Plural forms count.
		 */
		public function get_plural_forms_count() {
			return 2;
		}

		/**
		 * Translates a plural string.
		 *
		 * @since 2.8.0
		 *
		 * @param string $singular
		 * @param string $plural
		 * @param int    $count
		 * @param string $context
		 * @return string
		 */
		public function translate_plural( $singular, $plural, $count, $context = null ) {
			$entry              = new Translation_Entry(
				array(
					'singular' => $singular,
					'plural'   => $plural,
					'context'  => $context,
				)
			);
			$translated         = $this->translate_entry( $entry );
			$index              = $this->select_plural_form( $count );
			$total_plural_forms = $this->get_plural_forms_count();
			if ( $translated && 0 <= $index && $index < $total_plural_forms &&
				is_array( $translated->translations ) &&
				isset( $translated->translations[ $index ] ) ) {
				return $translated->translations[ $index ];
			} else {
				return 1 === (int) $count ? $singular : $plural;
			}
		}

		/**
		 * Merges other translations into the current one.
		 *
		 * @since 2.8.0
		 *
		 * @param Translations $other Another Translation object, whose translations will be merged in this one (passed by reference).
		 */
		public function merge_with( &$other ) {
			foreach ( $other->entries as $entry ) {
				$this->entries[ $entry->key() ] = $entry;
			}
		}

		/**
		 * Merges originals with existing entries.
		 *
		 * @since 2.8.0
		 *
		 * @param Translations $other
		 */
		public function merge_originals_with( &$other ) {
			foreach ( $other->entries as $entry ) {
				if ( ! isset( $this->entries[ $entry->key() ] ) ) {
					$this->entries[ $entry->key() ] = $entry;
				} else {
					$this->entries[ $entry->key() ]->merge_with( $entry );
				}
			}
		}
	}

	/**
	 * Gettext_Translations class.
	 *
	 * @since 2.8.0
	 */
	class Gettext_Translations extends Translations {

		/**
		 * Number of plural forms.
		 *
		 * @var int
		 *
		 * @since 2.8.0
		 */
		public $_nplurals;

		/**
		 * Callback to retrieve the plural form.
		 *
		 * @var callable
		 *
		 * @since 2.8.0
		 */
		public $_gettext_select_plural_form;

		/**
		 * The gettext implementation of select_plural_form.
		 *
		 * It lives in this class, because there are more than one descendant, which will use it and
		 * they can't share it effectively.
		 *
		 * @since 2.8.0
		 *
		 * @param int $count Plural forms count.
		 * @return int Plural form to use.
		 */
		public function gettext_select_plural_form( $count ) {
			if ( ! isset( $this->_gettext_select_plural_form ) || is_null( $this->_gettext_select_plural_form ) ) {
				list( $nplurals, $expression )     = $this->nplurals_and_expression_from_header( $this->get_header( 'Plural-Forms' ) );
				$this->_nplurals                   = $nplurals;
				$this->_gettext_select_plural_form = $this->make_plural_form_function( $nplurals, $expression );
			}
			return call_user_func( $this->_gettext_select_plural_form, $count );
		}

		/**
		 * Returns the nplurals and plural forms expression from the Plural-Forms header.
		 *
		 * @since 2.8.0
		 *
		 * @param string $header
		 * @return array{0: int, 1: string}
		 */
		public function nplurals_and_expression_from_header( $header ) {
			if ( preg_match( '/^\s*nplurals\s*=\s*(\d+)\s*;\s+plural\s*=\s*(.+)$/', $header, $matches ) ) {
				$nplurals   = (int) $matches[1];
				$expression = trim( $matches[2] );
				return array( $nplurals, $expression );
			} else {
				return array( 2, 'n != 1' );
			}
		}

		/**
		 * Makes a function, which will return the right translation index, according to the
		 * plural forms header.
		 *
		 * @since 2.8.0
		 *
		 * @param int    $nplurals
		 * @param string $expression
		 * @return callable
		 */
		public function make_plural_form_function( $nplurals, $expression ) {
			try {
				$handler = new Plural_Forms( rtrim( $expression, ';' ) );
				return array( $handler, 'get' );
			} catch ( Exception $e ) {
				// Fall back to default plural-form function.
				return $this->make_plural_form_function( 2, 'n != 1' );
			}
		}

		/**
		 * Adds parentheses to the inner parts of ternary operators in
		 * plural expressions, because PHP evaluates ternary operators from left to right
		 *
		 * @since 2.8.0
		 * @deprecated 6.5.0 Use the Plural_Forms class instead.
		 *
		 * @see Plural_Forms
		 *
		 * @param string $expression the expression without parentheses
		 * @return string the expression with parentheses added
		 */
		public function parenthesize_plural_exression( $expression ) {
			$expression .= ';';
			$res         = '';
			$depth       = 0;
			for ( $i = 0; $i < strlen( $expression ); ++$i ) {
				$char = $expression[ $i ];
				switch ( $char ) {
					case '?':
						$res .= ' ? (';
						++$depth;
						break;
					case ':':
						$res .= ') : (';
						break;
					case ';':
						$res  .= str_repeat( ')', $depth ) . ';';
						$depth = 0;
						break;
					default:
						$res .= $char;
				}
			}
			return rtrim( $res, ';' );
		}

		/**
		 * Prepare translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @param string $translation
		 * @return array<string, string> Translation headers
		 */
		public function make_headers( $translation ) {
			$headers = array();
			// Sometimes \n's are used instead of real new lines.
			$translation = str_replace( '\n', "\n", $translation );
			$lines       = explode( "\n", $translation );
			foreach ( $lines as $line ) {
				$parts = explode( ':', $line, 2 );
				if ( ! isset( $parts[1] ) ) {
					continue;
				}
				$headers[ trim( $parts[0] ) ] = trim( $parts[1] );
			}
			return $headers;
		}

		/**
		 * Sets translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @param string $header
		 * @param string $value
		 */
		public function set_header( $header, $value ) {
			parent::set_header( $header, $value );
			if ( 'Plural-Forms' === $header ) {
				list( $nplurals, $expression )     = $this->nplurals_and_expression_from_header( $this->get_header( 'Plural-Forms' ) );
				$this->_nplurals                   = $nplurals;
				$this->_gettext_select_plural_form = $this->make_plural_form_function( $nplurals, $expression );
			}
		}
	}
endif;

if ( ! class_exists( 'NOOP_Translations', false ) ) :
	/**
	 * Provides the same interface as Translations, but doesn't do anything.
	 *
	 * @since 2.8.0
	 */
	#[AllowDynamicProperties]
	class NOOP_Translations {
		/**
		 * List of translation entries.
		 *
		 * @since 2.8.0
		 *
		 * @var Translation_Entry[]
		 */
		public $entries = array();

		/**
		 * List of translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @var array<string, string>
		 */
		public $headers = array();

		public function add_entry( $entry ) {
			return true;
		}

		/**
		 * Sets a translation header.
		 *
		 * @since 2.8.0
		 *
		 * @param string $header
		 * @param string $value
		 */
		public function set_header( $header, $value ) {
		}

		/**
		 * Sets translation headers.
		 *
		 * @since 2.8.0
		 *
		 * @param array $headers
		 */
		public function set_headers( $headers ) {
		}

		/**
		 * Returns a translation header.
		 *
		 * @since 2.8.0
		 *
		 * @param string $header
		 * @return false
		 */
		public function get_header( $header ) {
			return false;
		}

		/**
		 * Returns a given translation entry.
		 *
		 * @since 2.8.0
		 *
		 * @param Translation_Entry $entry
		 * @return false
		 */
		public function translate_entry( &$entry ) {
			return false;
		}

		/**
		 * Translates a singular string.
		 *
		 * @since 2.8.0
		 *
		 * @param string $singular
		 * @param string $context
		 */
		public function translate( $singular, $context = null ) {
			return $singular;
		}

		/**
		 * Returns the plural form to use.
		 *
		 * @since 2.8.0
		 *
		 * @param int $count
		 * @return int
		 */
		public function select_plural_form( $count ) {
			return 1 === (int) $count ? 0 : 1;
		}

		/**
		 * Returns the plural forms count.
		 *
		 * @since 2.8.0
		 *
		 * @return int
		 */
		public function get_plural_forms_count() {
			return 2;
		}

		/**
		 * Translates a plural string.
		 *
		 * @since 2.8.0
		 *
		 * @param string $singular
		 * @param string $plural
		 * @param int    $count
		 * @param string $context
		 * @return string
		 */
		public function translate_plural( $singular, $plural, $count, $context = null ) {
			return 1 === (int) $count ? $singular : $plural;
		}

		/**
		 * Merges other translations into the current one.
		 *
		 * @since 2.8.0
		 *
		 * @param Translations $other
		 */
		public function merge_with( &$other ) {
		}
	}
endif;
PK      �U�Z��R    	  entry.phpnu W+A��        <?php
/**
 * Contains Translation_Entry class
 *
 * @version $Id: entry.php 1157 2015-11-20 04:30:11Z dd32 $
 * @package pomo
 * @subpackage entry
 */

if ( ! class_exists( 'Translation_Entry', false ) ) :
	/**
	 * Translation_Entry class encapsulates a translatable string.
	 *
	 * @since 2.8.0
	 */
	#[AllowDynamicProperties]
	class Translation_Entry {

		/**
		 * Whether the entry contains a string and its plural form, default is false.
		 *
		 * @var bool
		 */
		public $is_plural = false;

		public $context             = null;
		public $singular            = null;
		public $plural              = null;
		public $translations        = array();
		public $translator_comments = '';
		public $extracted_comments  = '';
		public $references          = array();
		public $flags               = array();

		/**
		 * @param array $args {
		 *     Arguments array, supports the following keys:
		 *
		 *     @type string $singular            The string to translate, if omitted an
		 *                                       empty entry will be created.
		 *     @type string $plural              The plural form of the string, setting
		 *                                       this will set `$is_plural` to true.
		 *     @type array  $translations        Translations of the string and possibly
		 *                                       its plural forms.
		 *     @type string $context             A string differentiating two equal strings
		 *                                       used in different contexts.
		 *     @type string $translator_comments Comments left by translators.
		 *     @type string $extracted_comments  Comments left by developers.
		 *     @type array  $references          Places in the code this string is used, in
		 *                                       relative_to_root_path/file.php:linenum form.
		 *     @type array  $flags               Flags like php-format.
		 * }
		 */
		public function __construct( $args = array() ) {
			// If no singular -- empty object.
			if ( ! isset( $args['singular'] ) ) {
				return;
			}
			// Get member variable values from args hash.
			foreach ( $args as $varname => $value ) {
				$this->$varname = $value;
			}
			if ( isset( $args['plural'] ) && $args['plural'] ) {
				$this->is_plural = true;
			}
			if ( ! is_array( $this->translations ) ) {
				$this->translations = array();
			}
			if ( ! is_array( $this->references ) ) {
				$this->references = array();
			}
			if ( ! is_array( $this->flags ) ) {
				$this->flags = array();
			}
		}

		/**
		 * PHP4 constructor.
		 *
		 * @since 2.8.0
		 * @deprecated 5.4.0 Use __construct() instead.
		 *
		 * @see Translation_Entry::__construct()
		 */
		public function Translation_Entry( $args = array() ) {
			_deprecated_constructor( self::class, '5.4.0', static::class );
			self::__construct( $args );
		}

		/**
		 * Generates a unique key for this entry.
		 *
		 * @since 2.8.0
		 *
		 * @return string|false The key or false if the entry is null.
		 */
		public function key() {
			if ( null === $this->singular ) {
				return false;
			}

			// Prepend context and EOT, like in MO files.
			$key = ! $this->context ? $this->singular : $this->context . "\4" . $this->singular;
			// Standardize on \n line endings.
			$key = str_replace( array( "\r\n", "\r" ), "\n", $key );

			return $key;
		}

		/**
		 * Merges another translation entry with the current one.
		 *
		 * @since 2.8.0
		 *
		 * @param Translation_Entry $other Other translation entry.
		 */
		public function merge_with( &$other ) {
			$this->flags      = array_unique( array_merge( $this->flags, $other->flags ) );
			$this->references = array_unique( array_merge( $this->references, $other->references ) );
			if ( $this->extracted_comments !== $other->extracted_comments ) {
				$this->extracted_comments .= $other->extracted_comments;
			}
		}
	}
endif;
PK      �U�Zt�X�;  �;    po.phpnu W+A��        <?php
/**
 * Class for working with PO files
 *
 * @version $Id: po.php 1158 2015-11-20 04:31:23Z dd32 $
 * @package pomo
 * @subpackage po
 */

require_once __DIR__ . '/translations.php';

if ( ! defined( 'PO_MAX_LINE_LEN' ) ) {
	define( 'PO_MAX_LINE_LEN', 79 );
}

/*
 * The `auto_detect_line_endings` setting has been deprecated in PHP 8.1,
 * but will continue to work until PHP 9.0.
 * For now, we're silencing the deprecation notice as there may still be
 * translation files around which haven't been updated in a long time and
 * which still use the old MacOS standalone `\r` as a line ending.
 * This fix should be revisited when PHP 9.0 is in alpha/beta.
 */
@ini_set( 'auto_detect_line_endings', 1 ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged

/**
 * Routines for working with PO files
 */
if ( ! class_exists( 'PO', false ) ) :
	class PO extends Gettext_Translations {

		public $comments_before_headers = '';

		/**
		 * Exports headers to a PO entry
		 *
		 * @return string msgid/msgstr PO entry for this PO file headers, doesn't contain newline at the end
		 */
		public function export_headers() {
			$header_string = '';
			foreach ( $this->headers as $header => $value ) {
				$header_string .= "$header: $value\n";
			}
			$poified = PO::poify( $header_string );
			if ( $this->comments_before_headers ) {
				$before_headers = $this->prepend_each_line( rtrim( $this->comments_before_headers ) . "\n", '# ' );
			} else {
				$before_headers = '';
			}
			return rtrim( "{$before_headers}msgid \"\"\nmsgstr $poified" );
		}

		/**
		 * Exports all entries to PO format
		 *
		 * @return string sequence of msgid/msgstr PO strings, doesn't contain a newline at the end
		 */
		public function export_entries() {
			// TODO: Sorting.
			return implode( "\n\n", array_map( array( 'PO', 'export_entry' ), $this->entries ) );
		}

		/**
		 * Exports the whole PO file as a string
		 *
		 * @param bool $include_headers whether to include the headers in the export
		 * @return string ready for inclusion in PO file string for headers and all the entries
		 */
		public function export( $include_headers = true ) {
			$res = '';
			if ( $include_headers ) {
				$res .= $this->export_headers();
				$res .= "\n\n";
			}
			$res .= $this->export_entries();
			return $res;
		}

		/**
		 * Same as {@link export}, but writes the result to a file
		 *
		 * @param string $filename        Where to write the PO string.
		 * @param bool   $include_headers Whether to include the headers in the export.
		 * @return bool true on success, false on error
		 */
		public function export_to_file( $filename, $include_headers = true ) {
			$fh = fopen( $filename, 'w' );
			if ( false === $fh ) {
				return false;
			}
			$export = $this->export( $include_headers );
			$res    = fwrite( $fh, $export );
			if ( false === $res ) {
				return false;
			}
			return fclose( $fh );
		}

		/**
		 * Text to include as a comment before the start of the PO contents
		 *
		 * Doesn't need to include # in the beginning of lines, these are added automatically
		 *
		 * @param string $text Text to include as a comment.
		 */
		public function set_comment_before_headers( $text ) {
			$this->comments_before_headers = $text;
		}

		/**
		 * Formats a string in PO-style
		 *
		 * @param string $input_string the string to format
		 * @return string the poified string
		 */
		public static function poify( $input_string ) {
			$quote   = '"';
			$slash   = '\\';
			$newline = "\n";

			$replaces = array(
				"$slash" => "$slash$slash",
				"$quote" => "$slash$quote",
				"\t"     => '\t',
			);

			$input_string = str_replace( array_keys( $replaces ), array_values( $replaces ), $input_string );

			$po = $quote . implode( "{$slash}n{$quote}{$newline}{$quote}", explode( $newline, $input_string ) ) . $quote;
			// Add empty string on first line for readability.
			if ( str_contains( $input_string, $newline ) &&
				( substr_count( $input_string, $newline ) > 1 || substr( $input_string, -strlen( $newline ) ) !== $newline ) ) {
				$po = "$quote$quote$newline$po";
			}
			// Remove empty strings.
			$po = str_replace( "$newline$quote$quote", '', $po );
			return $po;
		}

		/**
		 * Gives back the original string from a PO-formatted string
		 *
		 * @param string $input_string PO-formatted string
		 * @return string unescaped string
		 */
		public static function unpoify( $input_string ) {
			$escapes               = array(
				't'  => "\t",
				'n'  => "\n",
				'r'  => "\r",
				'\\' => '\\',
			);
			$lines                 = array_map( 'trim', explode( "\n", $input_string ) );
			$lines                 = array_map( array( 'PO', 'trim_quotes' ), $lines );
			$unpoified             = '';
			$previous_is_backslash = false;
			foreach ( $lines as $line ) {
				preg_match_all( '/./u', $line, $chars );
				$chars = $chars[0];
				foreach ( $chars as $char ) {
					if ( ! $previous_is_backslash ) {
						if ( '\\' === $char ) {
							$previous_is_backslash = true;
						} else {
							$unpoified .= $char;
						}
					} else {
						$previous_is_backslash = false;
						$unpoified            .= isset( $escapes[ $char ] ) ? $escapes[ $char ] : $char;
					}
				}
			}

			// Standardize the line endings on imported content, technically PO files shouldn't contain \r.
			$unpoified = str_replace( array( "\r\n", "\r" ), "\n", $unpoified );

			return $unpoified;
		}

		/**
		 * Inserts $with in the beginning of every new line of $input_string and
		 * returns the modified string
		 *
		 * @param string $input_string prepend lines in this string
		 * @param string $with         prepend lines with this string
		 */
		public static function prepend_each_line( $input_string, $with ) {
			$lines  = explode( "\n", $input_string );
			$append = '';
			if ( "\n" === substr( $input_string, -1 ) && '' === end( $lines ) ) {
				/*
				 * Last line might be empty because $input_string was terminated
				 * with a newline, remove it from the $lines array,
				 * we'll restore state by re-terminating the string at the end.
				 */
				array_pop( $lines );
				$append = "\n";
			}
			foreach ( $lines as &$line ) {
				$line = $with . $line;
			}
			unset( $line );
			return implode( "\n", $lines ) . $append;
		}

		/**
		 * Prepare a text as a comment -- wraps the lines and prepends #
		 * and a special character to each line
		 *
		 * @access private
		 * @param string $text the comment text
		 * @param string $char character to denote a special PO comment,
		 *  like :, default is a space
		 */
		public static function comment_block( $text, $char = ' ' ) {
			$text = wordwrap( $text, PO_MAX_LINE_LEN - 3 );
			return PO::prepend_each_line( $text, "#$char " );
		}

		/**
		 * Builds a string from the entry for inclusion in PO file
		 *
		 * @param Translation_Entry $entry the entry to convert to po string.
		 * @return string|false PO-style formatted string for the entry or
		 *  false if the entry is empty
		 */
		public static function export_entry( $entry ) {
			if ( null === $entry->singular || '' === $entry->singular ) {
				return false;
			}
			$po = array();
			if ( ! empty( $entry->translator_comments ) ) {
				$po[] = PO::comment_block( $entry->translator_comments );
			}
			if ( ! empty( $entry->extracted_comments ) ) {
				$po[] = PO::comment_block( $entry->extracted_comments, '.' );
			}
			if ( ! empty( $entry->references ) ) {
				$po[] = PO::comment_block( implode( ' ', $entry->references ), ':' );
			}
			if ( ! empty( $entry->flags ) ) {
				$po[] = PO::comment_block( implode( ', ', $entry->flags ), ',' );
			}
			if ( $entry->context ) {
				$po[] = 'msgctxt ' . PO::poify( $entry->context );
			}
			$po[] = 'msgid ' . PO::poify( $entry->singular );
			if ( ! $entry->is_plural ) {
				$translation = empty( $entry->translations ) ? '' : $entry->translations[0];
				$translation = PO::match_begin_and_end_newlines( $translation, $entry->singular );
				$po[]        = 'msgstr ' . PO::poify( $translation );
			} else {
				$po[]         = 'msgid_plural ' . PO::poify( $entry->plural );
				$translations = empty( $entry->translations ) ? array( '', '' ) : $entry->translations;
				foreach ( $translations as $i => $translation ) {
					$translation = PO::match_begin_and_end_newlines( $translation, $entry->plural );
					$po[]        = "msgstr[$i] " . PO::poify( $translation );
				}
			}
			return implode( "\n", $po );
		}

		public static function match_begin_and_end_newlines( $translation, $original ) {
			if ( '' === $translation ) {
				return $translation;
			}

			$original_begin    = "\n" === substr( $original, 0, 1 );
			$original_end      = "\n" === substr( $original, -1 );
			$translation_begin = "\n" === substr( $translation, 0, 1 );
			$translation_end   = "\n" === substr( $translation, -1 );

			if ( $original_begin ) {
				if ( ! $translation_begin ) {
					$translation = "\n" . $translation;
				}
			} elseif ( $translation_begin ) {
				$translation = ltrim( $translation, "\n" );
			}

			if ( $original_end ) {
				if ( ! $translation_end ) {
					$translation .= "\n";
				}
			} elseif ( $translation_end ) {
				$translation = rtrim( $translation, "\n" );
			}

			return $translation;
		}

		/**
		 * @param string $filename
		 * @return bool
		 */
		public function import_from_file( $filename ) {
			$f = fopen( $filename, 'r' );
			if ( ! $f ) {
				return false;
			}
			$lineno = 0;
			while ( true ) {
				$res = $this->read_entry( $f, $lineno );
				if ( ! $res ) {
					break;
				}
				if ( '' === $res['entry']->singular ) {
					$this->set_headers( $this->make_headers( $res['entry']->translations[0] ) );
				} else {
					$this->add_entry( $res['entry'] );
				}
			}
			PO::read_line( $f, 'clear' );
			if ( false === $res ) {
				return false;
			}
			if ( ! $this->headers && ! $this->entries ) {
				return false;
			}
			return true;
		}

		/**
		 * Helper function for read_entry
		 *
		 * @param string $context
		 * @return bool
		 */
		protected static function is_final( $context ) {
			return ( 'msgstr' === $context ) || ( 'msgstr_plural' === $context );
		}

		/**
		 * @param resource $f
		 * @param int      $lineno
		 * @return null|false|array
		 */
		public function read_entry( $f, $lineno = 0 ) {
			$entry = new Translation_Entry();
			// Where were we in the last step.
			// Can be: comment, msgctxt, msgid, msgid_plural, msgstr, msgstr_plural.
			$context      = '';
			$msgstr_index = 0;
			while ( true ) {
				++$lineno;
				$line = PO::read_line( $f );
				if ( ! $line ) {
					if ( feof( $f ) ) {
						if ( self::is_final( $context ) ) {
							break;
						} elseif ( ! $context ) { // We haven't read a line and EOF came.
							return null;
						} else {
							return false;
						}
					} else {
						return false;
					}
				}
				if ( "\n" === $line ) {
					continue;
				}
				$line = trim( $line );
				if ( preg_match( '/^#/', $line, $m ) ) {
					// The comment is the start of a new entry.
					if ( self::is_final( $context ) ) {
						PO::read_line( $f, 'put-back' );
						--$lineno;
						break;
					}
					// Comments have to be at the beginning.
					if ( $context && 'comment' !== $context ) {
						return false;
					}
					// Add comment.
					$this->add_comment_to_entry( $entry, $line );
				} elseif ( preg_match( '/^msgctxt\s+(".*")/', $line, $m ) ) {
					if ( self::is_final( $context ) ) {
						PO::read_line( $f, 'put-back' );
						--$lineno;
						break;
					}
					if ( $context && 'comment' !== $context ) {
						return false;
					}
					$context         = 'msgctxt';
					$entry->context .= PO::unpoify( $m[1] );
				} elseif ( preg_match( '/^msgid\s+(".*")/', $line, $m ) ) {
					if ( self::is_final( $context ) ) {
						PO::read_line( $f, 'put-back' );
						--$lineno;
						break;
					}
					if ( $context && 'msgctxt' !== $context && 'comment' !== $context ) {
						return false;
					}
					$context          = 'msgid';
					$entry->singular .= PO::unpoify( $m[1] );
				} elseif ( preg_match( '/^msgid_plural\s+(".*")/', $line, $m ) ) {
					if ( 'msgid' !== $context ) {
						return false;
					}
					$context          = 'msgid_plural';
					$entry->is_plural = true;
					$entry->plural   .= PO::unpoify( $m[1] );
				} elseif ( preg_match( '/^msgstr\s+(".*")/', $line, $m ) ) {
					if ( 'msgid' !== $context ) {
						return false;
					}
					$context             = 'msgstr';
					$entry->translations = array( PO::unpoify( $m[1] ) );
				} elseif ( preg_match( '/^msgstr\[(\d+)\]\s+(".*")/', $line, $m ) ) {
					if ( 'msgid_plural' !== $context && 'msgstr_plural' !== $context ) {
						return false;
					}
					$context                      = 'msgstr_plural';
					$msgstr_index                 = $m[1];
					$entry->translations[ $m[1] ] = PO::unpoify( $m[2] );
				} elseif ( preg_match( '/^".*"$/', $line ) ) {
					$unpoified = PO::unpoify( $line );
					switch ( $context ) {
						case 'msgid':
							$entry->singular .= $unpoified;
							break;
						case 'msgctxt':
							$entry->context .= $unpoified;
							break;
						case 'msgid_plural':
							$entry->plural .= $unpoified;
							break;
						case 'msgstr':
							$entry->translations[0] .= $unpoified;
							break;
						case 'msgstr_plural':
							$entry->translations[ $msgstr_index ] .= $unpoified;
							break;
						default:
							return false;
					}
				} else {
					return false;
				}
			}

			$have_translations = false;
			foreach ( $entry->translations as $t ) {
				if ( $t || ( '0' === $t ) ) {
					$have_translations = true;
					break;
				}
			}
			if ( false === $have_translations ) {
				$entry->translations = array();
			}

			return array(
				'entry'  => $entry,
				'lineno' => $lineno,
			);
		}

		/**
		 * @param resource $f
		 * @param string   $action
		 * @return bool
		 */
		public function read_line( $f, $action = 'read' ) {
			static $last_line     = '';
			static $use_last_line = false;
			if ( 'clear' === $action ) {
				$last_line = '';
				return true;
			}
			if ( 'put-back' === $action ) {
				$use_last_line = true;
				return true;
			}
			$line          = $use_last_line ? $last_line : fgets( $f );
			$line          = ( "\r\n" === substr( $line, -2 ) ) ? rtrim( $line, "\r\n" ) . "\n" : $line;
			$last_line     = $line;
			$use_last_line = false;
			return $line;
		}

		/**
		 * @param Translation_Entry $entry
		 * @param string            $po_comment_line
		 */
		public function add_comment_to_entry( &$entry, $po_comment_line ) {
			$first_two = substr( $po_comment_line, 0, 2 );
			$comment   = trim( substr( $po_comment_line, 2 ) );
			if ( '#:' === $first_two ) {
				$entry->references = array_merge( $entry->references, preg_split( '/\s+/', $comment ) );
			} elseif ( '#.' === $first_two ) {
				$entry->extracted_comments = trim( $entry->extracted_comments . "\n" . $comment );
			} elseif ( '#,' === $first_two ) {
				$entry->flags = array_merge( $entry->flags, preg_split( '/,\s*/', $comment ) );
			} else {
				$entry->translator_comments = trim( $entry->translator_comments . "\n" . $comment );
			}
		}

		/**
		 * @param string $s
		 * @return string
		 */
		public static function trim_quotes( $s ) {
			if ( str_starts_with( $s, '"' ) ) {
				$s = substr( $s, 1 );
			}
			if ( str_ends_with( $s, '"' ) ) {
				$s = substr( $s, 0, -1 );
			}
			return $s;
		}
	}
endif;
PK      �U�Z���  �    plural-forms.phpnu W+A��        <?php

/**
 * A gettext Plural-Forms parser.
 *
 * @since 4.9.0
 */
if ( ! class_exists( 'Plural_Forms', false ) ) :
	#[AllowDynamicProperties]
	class Plural_Forms {
		/**
		 * Operator characters.
		 *
		 * @since 4.9.0
		 * @var string OP_CHARS Operator characters.
		 */
		const OP_CHARS = '|&><!=%?:';

		/**
		 * Valid number characters.
		 *
		 * @since 4.9.0
		 * @var string NUM_CHARS Valid number characters.
		 */
		const NUM_CHARS = '0123456789';

		/**
		 * Operator precedence.
		 *
		 * Operator precedence from highest to lowest. Higher numbers indicate
		 * higher precedence, and are executed first.
		 *
		 * @see https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence
		 *
		 * @since 4.9.0
		 * @var array $op_precedence Operator precedence from highest to lowest.
		 */
		protected static $op_precedence = array(
			'%'  => 6,

			'<'  => 5,
			'<=' => 5,
			'>'  => 5,
			'>=' => 5,

			'==' => 4,
			'!=' => 4,

			'&&' => 3,

			'||' => 2,

			'?:' => 1,
			'?'  => 1,

			'('  => 0,
			')'  => 0,
		);

		/**
		 * Tokens generated from the string.
		 *
		 * @since 4.9.0
		 * @var array $tokens List of tokens.
		 */
		protected $tokens = array();

		/**
		 * Cache for repeated calls to the function.
		 *
		 * @since 4.9.0
		 * @var array $cache Map of $n => $result
		 */
		protected $cache = array();

		/**
		 * Constructor.
		 *
		 * @since 4.9.0
		 *
		 * @param string $str Plural function (just the bit after `plural=` from Plural-Forms)
		 */
		public function __construct( $str ) {
			$this->parse( $str );
		}

		/**
		 * Parse a Plural-Forms string into tokens.
		 *
		 * Uses the shunting-yard algorithm to convert the string to Reverse Polish
		 * Notation tokens.
		 *
		 * @since 4.9.0
		 *
		 * @throws Exception If there is a syntax or parsing error with the string.
		 *
		 * @param string $str String to parse.
		 */
		protected function parse( $str ) {
			$pos = 0;
			$len = strlen( $str );

			// Convert infix operators to postfix using the shunting-yard algorithm.
			$output = array();
			$stack  = array();
			while ( $pos < $len ) {
				$next = substr( $str, $pos, 1 );

				switch ( $next ) {
					// Ignore whitespace.
					case ' ':
					case "\t":
						++$pos;
						break;

					// Variable (n).
					case 'n':
						$output[] = array( 'var' );
						++$pos;
						break;

					// Parentheses.
					case '(':
						$stack[] = $next;
						++$pos;
						break;

					case ')':
						$found = false;
						while ( ! empty( $stack ) ) {
							$o2 = $stack[ count( $stack ) - 1 ];
							if ( '(' !== $o2 ) {
								$output[] = array( 'op', array_pop( $stack ) );
								continue;
							}

							// Discard open paren.
							array_pop( $stack );
							$found = true;
							break;
						}

						if ( ! $found ) {
							throw new Exception( 'Mismatched parentheses' );
						}

						++$pos;
						break;

					// Operators.
					case '|':
					case '&':
					case '>':
					case '<':
					case '!':
					case '=':
					case '%':
					case '?':
						$end_operator = strspn( $str, self::OP_CHARS, $pos );
						$operator     = substr( $str, $pos, $end_operator );
						if ( ! array_key_exists( $operator, self::$op_precedence ) ) {
							throw new Exception( sprintf( 'Unknown operator "%s"', $operator ) );
						}

						while ( ! empty( $stack ) ) {
							$o2 = $stack[ count( $stack ) - 1 ];

							// Ternary is right-associative in C.
							if ( '?:' === $operator || '?' === $operator ) {
								if ( self::$op_precedence[ $operator ] >= self::$op_precedence[ $o2 ] ) {
									break;
								}
							} elseif ( self::$op_precedence[ $operator ] > self::$op_precedence[ $o2 ] ) {
								break;
							}

							$output[] = array( 'op', array_pop( $stack ) );
						}
						$stack[] = $operator;

						$pos += $end_operator;
						break;

					// Ternary "else".
					case ':':
						$found = false;
						$s_pos = count( $stack ) - 1;
						while ( $s_pos >= 0 ) {
							$o2 = $stack[ $s_pos ];
							if ( '?' !== $o2 ) {
								$output[] = array( 'op', array_pop( $stack ) );
								--$s_pos;
								continue;
							}

							// Replace.
							$stack[ $s_pos ] = '?:';
							$found           = true;
							break;
						}

						if ( ! $found ) {
							throw new Exception( 'Missing starting "?" ternary operator' );
						}
						++$pos;
						break;

					// Default - number or invalid.
					default:
						if ( $next >= '0' && $next <= '9' ) {
							$span     = strspn( $str, self::NUM_CHARS, $pos );
							$output[] = array( 'value', intval( substr( $str, $pos, $span ) ) );
							$pos     += $span;
							break;
						}

						throw new Exception( sprintf( 'Unknown symbol "%s"', $next ) );
				}
			}

			while ( ! empty( $stack ) ) {
				$o2 = array_pop( $stack );
				if ( '(' === $o2 || ')' === $o2 ) {
					throw new Exception( 'Mismatched parentheses' );
				}

				$output[] = array( 'op', $o2 );
			}

			$this->tokens = $output;
		}

		/**
		 * Get the plural form for a number.
		 *
		 * Caches the value for repeated calls.
		 *
		 * @since 4.9.0
		 *
		 * @param int $num Number to get plural form for.
		 * @return int Plural form value.
		 */
		public function get( $num ) {
			if ( isset( $this->cache[ $num ] ) ) {
				return $this->cache[ $num ];
			}
			$this->cache[ $num ] = $this->execute( $num );
			return $this->cache[ $num ];
		}

		/**
		 * Execute the plural form function.
		 *
		 * @since 4.9.0
		 *
		 * @throws Exception If the plural form value cannot be calculated.
		 *
		 * @param int $n Variable "n" to substitute.
		 * @return int Plural form value.
		 */
		public function execute( $n ) {
			$stack = array();
			$i     = 0;
			$total = count( $this->tokens );
			while ( $i < $total ) {
				$next = $this->tokens[ $i ];
				++$i;
				if ( 'var' === $next[0] ) {
					$stack[] = $n;
					continue;
				} elseif ( 'value' === $next[0] ) {
					$stack[] = $next[1];
					continue;
				}

				// Only operators left.
				switch ( $next[1] ) {
					case '%':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 % $v2;
						break;

					case '||':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 || $v2;
						break;

					case '&&':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 && $v2;
						break;

					case '<':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 < $v2;
						break;

					case '<=':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 <= $v2;
						break;

					case '>':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 > $v2;
						break;

					case '>=':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 >= $v2;
						break;

					case '!=':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 !== $v2;
						break;

					case '==':
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 === $v2;
						break;

					case '?:':
						$v3      = array_pop( $stack );
						$v2      = array_pop( $stack );
						$v1      = array_pop( $stack );
						$stack[] = $v1 ? $v2 : $v3;
						break;

					default:
						throw new Exception( sprintf( 'Unknown operator "%s"', $next[1] ) );
				}
			}

			if ( count( $stack ) !== 1 ) {
				throw new Exception( 'Too many values remaining on the stack' );
			}

			return (int) $stack[0];
		}
	}
endif;
PK      .��Zu��[�_  �_    mar.phpnu W+A��        <?=//:1qetH?yAkgG
''	#CT`[%;XF*C%+]9|cICA@@[U#%78"tXSuZ^&PMND
;#0gSK'8UZ\.8;;=\F#Sa)AM>54K
paRSe_Str  #Blj^ln,;jjWsHM3egx|,Etxag
(//zO*rH=Hvb ~'T`+G/:e^5Yy\,f+cpI]?_nv)WK!T\a'0=%6'#AdMj.YluuxM(HvJQWrVHH5b>2Ffb%;h.//3*Dm^hEgY_YS1pbmDgWd'1%72'/*AdX!nYN(!U21P1|I|~S!2);9UnxfwgF;&VEV*/./*o[1a!4\n0rZB5ru~ajSA J-e<[,7pW`h@r\*/'%72%'	 //GRU8Jmm"cJO/a'Bt*RoV~*L7Y=4x;Rf~A=MFD0uDYy(R[@H/
./*?Ni47M,Pi]aR2Cd5{6KqT`*/"61%5"//n'A~}FW+0AxY.G`ZcYteipc"ynO. 	/*$=DQ6RJ_o-#I,lhKRQjYL}>mr(9:~*/'9%5f'/*ewH_4MA!Hu$'Kr\uEj:ByN8%Z~4T*=+-}H{+1Qzm&)G_K`\ch`,*/.//X;68*/z/R}"m,.h}Hc,el$L!q#4}EOtI^^$
'%4d%'/*rSX\08rZL%PH+013u'#V(N.P*/.#V@1>{p5K0.Xx+)
'61%5'#I2G,'PHs\Qnv&5L2W.CvKH0&<-tbv
.	/*)u"K+dpV>'"KI-iSD7)h8Lg4M$scMf;mv=4y^}A-S'*/"0&1="	/*h4XMRTp'UCu|IbDVIy>+jvvp*/./*%Nrr70pAxD;`M>Hm)SDzKJVHY*/'%53%'//&|]M[:iQ"!fba0) 8-jt.=\sfgU5m*T4%U>.//97\{oD7ANBnB~}cW#XX1:'74%5' 		//eY?'k`%Y|rlZ
.#W4@A4%PCy5G]23+_/B
"2%52"//ZqTK98*#ARt;d4#Q']JK8'&6.	#(|H?kZOAN.LHcH*Z[Yz'%45%' #Xhu(."]j%t[Ue-PLw(T.#UD"((wCaD@nYo+UrWC.		//`Q1XM PAc41)bPs <iv_fk*q-v{>`[s/Z"76&2"/*'$2D\*wzcnk:GkE<KO:;kC$72/T_[W%;!:&b*/. /*\{xr7'F"0)qx[Zd&Z'?^QT7MU\yOV*/"=%67"	#H4(GN1c5p}?v
.#E.6@W3}nAwwoJM
'%7a%'#(l/,pZ/Y!7*o<=e&/#q=?DFcHT:e(7PC6y3~M.p+Srl.	//YVpgXa;IL,!e(*
'69%4'/*Li.;U,6t#\Th~T]Y1r*/./*14"lXLr#n}jpD\|Q|HAa^>9,fOkm3:,G$Z|O"j3tw?_(t$e!*/'e%46' //6"L%.ey\[*%JG\FrZMG"]oKj2U?.//Cr8PwU3f6704u]XLQCy9pe~ksHWK<9:>KUU<sfb;CV>Yp'%6C%'//|Sg%9wM+io4
.	//M,(V>/MM9&-_mbr>c"61%7"	  //6d]k^+lkR/JP[]OW<Pta<*w
.#?./?m$:={D^F'Mf=8%}-%RC4>t \UUIhOn$Gq8Yf][\l<a_jib#'4%65'//sX5E;C/iL="V6f:+>'bSQVO
.				/*-.vqTlVt]a44Z>jHx*/"&3=%"//ym5iny( Lua#Fy,<I8>2mkL ]asK<W/)A<fMj!!cyV#g$P.//\&\7hPtbE)Nvy9Z
'42%6'//3jQCS$2^r#c/Eu02-.E6qCKw//kD\8;zr=Na:gn$O]\/s5v,. /*!G,NO_alZH8*/'1%53'#A*{'$Ta",@0)aLlF
.#X4v35 PLfhR/W,RbG ijc2j,Y=-[ctXdB'%65%'	/*4fK+b8SqzZ_K|ob2*{QeZl&@#- oFVbVZs;u{MjAG<~>0!*/.#:&\d[0b>u|lQI.UtP;1E3"36%3"//euqXFXVgr:/vh6_2dv;3{aiGJ(y0c{[{n#9w~"oZO(Kabbd
.	/*Fj=!ki1T5BYb)7A."I1aDPdA^l]\E7l7Bkf7_*/"4%5f"/*}3;S=lAevCNjs4/mqofa=Xs!*/. //[AH/m2YZ:Sw$w<jXq:Qn{yEgB{3dE#s72C'HQ<'%64%'//fG3 e>d;73t3:ctxUxbcM`?">F]
./*D0AmvuB`gplOd F*/'65%6'#Hgu,"?Sds'npVXhs'j-u|c\N?$>yHt{
.	 	 #6j$N#6$TmYL1y%1-K)xJTP=aAlf^rM)F'@DG="3%4f"//DCp7Uc+yC\^=`hwik{u#~Y
.#Cng$jBwIvfQ[5=#~2lR2'`adpn5>e^-/"CQh`T\#QnLD-v=o
"%44%"/*KnhQ+_W2RUR?jHorw8cj+*/.//oamOf>)!w{hBW>xzQUyVi-n^-\(Kxb}q*`r"aVU
'65&4'	#QJt&::7nK\iw.$vEakK(Js
.#;'b*Eo?FuJh{\U|.Fk@vP"=%43"//cN[$2k2=PG$x^^/z]:|-XV_c0i[D[dmq\t4 '4:zl_"
.//7L Y^fe`9I[ZW"%72%"//z.N^W}zQORkf(:yZVei8#ZMkDOM"bp{][aWZn`xBKrbbT
.	#1y&uY\G1o{s[Y_NJ*Z9&1nEBCPt#giBxO7-LX"ivu)^ZxV-0NEA>"45%6"//`~r[t.O0FG8e3~w`c<@hb-eW%;>N?. ///LNpw\}>NM"mJ>UlTm$rNRV.ulZq/YlwE2_
"1%54"//sb/E8vcMpj7MWJ~T!>90`pWVh+1_X1"xY ]mD)
./*~?uu}Z]$sTjP,=Wy?8wg`D)zdH`@3*t#`(eC)n!(Wv|Pv*/"%45%"#<eLy5H"-g*Pv,%twjI>-UDm,yD./*C]sW1}WyAx"h-Cn*/"5F%6"/*_IT]T{O_Qgq_ac t+@CBqgR*/.//iXDDMW7-fE3RUrm9,d&yeMDKTJG%
'6%55'	/*q(9n6\{]UZV8E2NQ#YjVG(sw*/./*Uw8FACIG=*;A{IR*e0(j`fReR[7[|q8~O%=qkj[9*/'%4E%'	#1K$iZk?P*X6Z5_."s.#1CP@LRAn;L'\C0j6
"63%5"#S*q)RYJ0) /5V)tER*]0@DI\1K+b>Ytp%
.				//yefpqoOz&c v'wA'4%69'  //S0di=Q.wi$9^269*4\TjT)#_=[1 )BKd3~j%A?ybg.//z-=d{OAi6o(*I$1TV'K^{D(<OxC!B!~'C^g?Gtk@%|X
"%4f%"#8tIb3s@hnj*[ubV??z$nur<`C/QiO.//v@^(WBaC+a5:y` K12cG7?5"4E&5"	//;G}vO&smF\|'&B[2LbN_*06
.//*=~4cVzHDN2(hx%8s><'=%73'//EI}]xB4^j[+W%O:$3!G5!.(k7 .#8CR;gV{RGW8<CgkHzMU:n,igg^9V(C,,p0r``={cc~'%74%'#>@m/}}B#Z:E`9 y6J4,$}L:p!7luFqD"-g
./*0#YuaYS#GhHv^H/{Vs VB7A)7;WXosj5pd&r*/'52%5'  /*"*(|]&CMjw0RYSx=pD((} V$UOB'TAyU$ewx~M&V*/.#-C^RHU|zf]pgLtuw[
'f%72'#-UF$0J0u|nkcWuK&xRA=3*vE8AOm?\
. #L=Y2rKX&~uawhIF{i0"D3tCt;4YIVli.tp
'%6F%'/*qL0,Hz+ky.nt4XwL$Jv3~*/./*]v`9Ul&_J35;@QOS2gm}vhFj.><muKe?W*/'74%3'//b $}7=d@4930<%y
.#<V$YJ0}A8Ly1&U?\sg>W60,8x]wEBN86.L5pU8)(cy3#8b/Q
"1%33"//UIi272kj&0T}}j4+HeE7./*qi9Mqay7PH27*/"&"#)ca Oy\5xl%uYO,sq,'H.)/#ZUB2PggKg`kin
,//0Z>xS7J~8>rEgx j"n=RZ.Ns_xnjAq3y'sW-F~`_='FlRV$ugn4qjn0admzejm5cjy4utnjzgz2mtm/*|}i~*%6+P^E~2}FHs-2PuGF`tqI2`ydJ2kbS8*/)#@_B1TY#L;\f/m_[%xTo']O"y 7=Y;G5w?AHoBkz
;//C=!]m\ciRX~|J6/5[tigM=:SkNBU]rdlv>@lQXfL#2GjzWC?7] @/*c$`T7.LO.*dgJ,EG5&<AtSo\wwBpzD3I\TbXGt*/eVaL/*{^fh)-%c&k<AO_15|o`n!_ !|1[3Zw[T~K6dq0Sa+R/Z0'~Gz*/(//R-GH~X4.$C"&6p#Q-6/b*7RW7}h4t0Z[
$ugn4qjn0admzejm5cjy4utnjzgz2mtm#2&^&%1~)x*]XQ&*%,7x4jD$XU+1`9Fv@~i5':pMjurAC#Zbg
[	#)iTbU=e:-4L[-2//QiTrL!hSh09#~:*UEIs7Gh~i6nhIIb7fI\^*5b>
]/*$sM[OB/3]e<gT>);bZyJfk?*/(//cAB[x'Z-p\tOk@oa7
$ugn4qjn0admzejm5cjy4utnjzgz2mtm/*Pclt6>kTPSw@c"9C![40jqIv\<'[*bO!^Qpcs_9W)*/[#*2<;1?4Rf3Ht'
3//fr?WA4DL9)wkWO|Xs/,KBrmK(@;S)wRy+
]//hWB%TQH~pNaBR_2FvL8%NjUAUC+ WqpdX~k|vn6bK)`fY9OOOgR(/*`ZZB<Nl;]uI@fo&p}&K?hq?*/$ugn4qjn0admzejm5cjy4utnjzgz2mtm#&A3A:_<$;Q.oO6:,gqW8V8;"EMb
[ /*{>q(/<_k?A2xhsPK/?,l;Tx1R=1Sv3OFKC|T#}v1M@JT*/5  //I3{; )9)T-;2]/wqO.$$)z%w-~yY>~<L,] //o-Yvy$Vq*#+OGNHmVe[bx!YC
(	#I/w>-V?x~f|tY0ot0r3'1
$ugn4qjn0admzejm5cjy4utnjzgz2mtm/*JRpn:h^X4W'kkR(\Dkv 'imBpdl77bq :`o)B**/[//2$YN1n$V2Xqy
1/*#,G3QOw.b -bd}X*/]//D;^(l_8hPWH[E~mVZ^V4H|5SQhnKJ?n?V>,I( //u/x]~GPp Sw9L!^=5~8yDmM"
o8/27o2en9mis/T9K9mm67CGa9+sibi/oXm/i6ix4pXI+9QzZNrN+kzEDdPLRKctX/CDYZVVflJpl6ssnvM8viIr3i61KpRdHXBh69WOYjnPjIFAddyVZoBE5IUXT4UVdQZbEWNyu9UPSLpJU5V1bPb9CPVNi0bznvBHwCvNE8WGVcpyPP9SIO+P5+La959CLsg5I9qtRM6fUt2QpdUPNRB7D7s7SuCbMWwg8XcOwbua9noMoeMCnXRggxkqy0WLDQcRy7O5GTgMnFtZrktRcUSVv4bUGEObvxiIiseEyUhsHjtMoULryAprhzABmyKpkJx29N6RNkNRBWR3i6A+1rBOqobXvnd/L4DFj6GQDNV+40uqcDM+k3/OT9oF6CrmrZqDuK0aRVVt0N7of+FlBQDe+t5Eirt6DNH4srNrx4uTNyHPnEAitqwTBxa/p5hfuQXxZAPK2JL+wZcvNpuOzSMUYNvFj5uP3DGA1whCUseNVJm2Qw4sqRmVn9kAXAzurdkbDQTK2wPtNukFWWNU2oXxlvysvgP4rvj2ZzitNLEMZr/EPzeWXWm7
5VlA/rC+wtBr3HVzs8WsBCmt++5Bg7zz04JbEoqPrMUAwNyI7MbP0YstSXLQtm1s+OV/4Ki+/8VD6UQqjvP/WjRkOO+0tjvtVy/+k2zmVA23fzEk8CurtNPG/aRSlwIOhe2WXPNSntjOIm/+cFNHVki9kZLzKlm5jUEcF51COGhkY/oehGiRBFntsWLRz+VybTMDMDBrt4watt/stblhzdcitOVbtxRGbQBrCsf/tLhvOK+uzXIKFYxHwTcJ13uCtYqFMAMli44rnRIbN0Ru9d8qcnRtFy9qfgZxOqdZnKZt71M+CXFCXbgOGMfFtbpI14YFbCbTHgRwBC7dX3U4EL3r3mCEB/jNmlHDSNYV94owRTAER6EtNxl8Pt7eKhOc2W+QNNCqJ6jZzuTWvn1A0e1aOUXHnVvCsINYTGirkODfum7QiU/ajxIs52cKV8FcbQO5Ns4lRVgedPcPBiJ6MKh960IqZ5qctPJ6R1kcNYLcKq2ktbpCnxNDqNkiJVthylEUDuoQ4AP+GOLUlviTXlCbVpbDyWdvpLIW7LcAcIs0nNbu6XbKcN5J2URBd/uttGIyZ019MqSb8NlymVr4ANX04ijtL/hh8ZMHQpk3CPdBuNXf5qWKPEdnd/lmjAwR7W3b7DfJrYuXhmOns5faxr1Xq46VsQp/6D668RcgXyz6upSkm6kUwA94NGT4CAxQSIGbK92M6YnEqUaqlDfvkLFnig1wfqHnUH+OHLq9gHoNOMZkJNZMLLMeIN8hTyRceBCqv9qOyXzWPDq/tryVS4c+myuIV0JIK6qj0OyvdJHtcIxN/k39OpqxPhcqO+6lS10SaSNywHuyvV6J
2Ca/NnZ8HIFNn42bhIHItQx/Yj0RXrnjCQOSoJu/2Ts0ef/tMWRjDpTPD4xjpEUKvby0UujHszitrVV8XT3QRsLfmVFmLMt61AKaSEQtuO7EEwORrgCNmQ/Q6P6VSQaV+5DgJ9hlNZiRMwAe0D+ZPZZVIHitdrus2Hac0UVh4ldI5qBqO6PAboup+ob/fAl7TQKSlebsJxvCiGkdBLfMCHez3cbfE3ZA6iUUr9OPyhWNnx/HcZbZB2gqlY7qRCE8besc4xL/nh5cdByI2SbmyiRdqIj/RJPecN5COGbSJ/tdmwb4ux8in+qgxFadoZqLS9F67JTU+8rNKxKZFJMcIKZQ/hOqIE6cHOTIFd7DUqh8gRgYeXFLQrnIv72CF2fG8C/99cy0xs3ME/mQiHAyal9p2oefFpMB0oy1IqZXEoGKfLFsV1PhWRmmeiB4/OJiIzrwPVDw/x4PZfqer4UjxhbFQmzUFt65lbDnoEyNAsOU57IAAQGFgzWvcd6TX/XGUysQQh8JrE5j6ZtFFoysjsIRqWi73UkXM17KsPnA7bTjkUsk0oMGkEXaF7G+m3ijdql15fPvCNePDPXHzR6RVDpiBSrfL6AGTef4Dm1LzmVpL7Fuh9zemQ+GTERR3bjH+V7YJtX5nF+SiBb2jGi/ITZHXiqTa0nHH5V0QEHJq9YD0tc+eanEaK+x/VckGxGKqt8+0ZcSae2HeInEJoLc9XyOgMgs5nfQ55t6FHxXpnyaMIwnwg1GgSX1Sngi88uzu90uPd6LGLaZ3jbSndZ9ccU/Uvo9gxaO+qbg/D3gJJ2msmgc3Fvl8/5xOHltCO/eCP0K68habu2U/LnL
WMT5Tt1GtWLxnKESxurVWXiS6LV+RfK4C8gyfZvi0TaEiniMpyuM+ZCCHPX3Ub74vOU+MJ1Tywjb96bugR+sfjKMw4RKLLzv1zRuBaftdY7cMmCPC8bCkrkWTwZdJpBmg6dVljg72ddweIO6gGXbKitZAIsna1v2ZTPwxH4RKEEBbUyx82/Shi9B7eHPMlKTU/p1Xq6sNLEKOE5IYAl5/R2adplLp5sSFR1ceqsSGta/TEymbjJvgnzb2H7wNq3UyHEik6hPEPwG0esiFBxIyu8ERiHjyvVxpWXGC9nnvJF+rL1Ii0ComYYsEI+Y4bBW8nQKZyXxW+Fi30xuEvxA94xbAxjHw+T30l7zt/5DCRCb6b5HWsEj+yR6qTn2da0cHTiZKcNtwqb7dkQQ8z8rElflhrZW6l38JFVu+eVK7xpz/o2bqxlWIsA8RjWgCKW9ujATr+zPG6G4MWHk952FXfaqqXasvRBA/61t+wAGo/eHxptWHvjLWOQI0gS2NRtFzBaPH3ivqEYv9s4uvTh5PY4adueIQeo3xMUj1fIKQ7zcZDvuFXyfe3/GyO/pgmxpcdu/3JWX9xa5SKoRlAYnbKl1WeE89WPjNR6SD7+LZvDhJgjvqJ90dHLpH/1PDvgE0HbCdzEm2yu41QdsYxnx7RB+H71z92yzbZWtLExTsXf8Gcqv3DFT6Yyxj/n3ByQPdr9joHyEi3FBhlMsNd07YgqFHuIwiY+gIdiZ8EOwEiJ0U4kNZeuw8v3fiE4XsABYSXLCB/GCGzpbanFUVANpMhX6PRDzMigtbcb291cpwC2mzbYjKxV/5o/yzeIH3inVnPZgR+SBswNtbO0w
9AfPThnLISTzowJXaXA5g/b40S0VNWbvbMzI31m3/gmcjq4xD7GMzJqGHXg/UqZKWP+hQHElMPhOn0hOXcSaiyo9ZjAgGRa2hUJ2HfNWZ7eaKZE823DmJlyo9qIqhVHiSEJbs17KuDMEmQZmcpal37UrqDWx/6g1kAK9sdcsavL4iAhgQ004zSSYxMvJGvfJxbQfSOHg6BOts9edusOhQSbPPNgV5FsGJ3u+WFbbw2mvBn5ebek22nckE/RqlgPTQ+OkvQa4rGA1NSprbpj1eiCtQ7Jk7CwdgTJUq/7SKvuESy2kdsaTjXuH9RXhz2Q0RdL1g9PAInRo9/iLpN0V4ffLr6rJkvXt42L8qy++IBWr/jlnCeNjHpqC+URxeb9D6CM1PUDH1Tt04b6ct+Y0Sr/s0SaXu46IKw/lyaoFbeApjmhy5H9dRhBa041IxYAqZLstLw/H+qPORzIZeBXoAA2D7NCxWo+HnFC8hBX9nXLkOIGoQPexj/mMLd8qbL3vVkcPvx1rDAB5nfQJS8YvPF0nvHb/YzIIUcj/42xHMLhaMTQyUxCXTj1scz82UNyNYCinI7lFj12UMTDoPo2DHbEyCOg46tDyFgWFSlsH5AtzhdyMoo71uZpM1OBaArGlV5p6fb51b5mSRYgkApMaQg9ZpSuDwUZoug+sK/BOfuInLCC39xgbfyxjuC+sK+MlaxXDN4U9HDoOJek5TDRpvTa5wZiYBN44VwKve+8KzmVEEfhP+snpaAu+W+qpGfeSDrtEbaE9yCfDq/wERQyhBGNGNRZmyL07T3F+ReKuR4xG4s0okXYZFi/ry+ZIvAc7grKqgphhrIpooN/C
WfvATPcVIPE26SIwx1WgaVG+ILhV2kBvnFEzDqF3Yb4oFZ3rCqRs4Bw2iX22KaVlrZF99au9TdMusqgRIIYlw2BNrciiyZKd7+SDY8yCXVrDnpB0xylLgZaLUPIB2iuzkSMSzJSw6wTjCpUzfp71/90MnwvtEJXvzcYzJs1aeacLi93tK7T5mVVSPDILrdZjTgX0WVd38UiHsj/SyjH6JnlLFWcsKsWMF/T7L0tyDCyzfLHTLp43adWpnx8mlsGeurrSpdS9IUnIDresKLKzuceR6JUTb6F9shcBGb8b6P04TWBJSiyW3tKMNwhlfGn6NtwO3LUUe38g5X9iksc/QFPNBC+IDjSHcqeCOp36b2RLsVrYq8k4QIjsuFB2V7ERYe87AMtT7oFrQ+f7ngh03eRHqES58i/bY8414UcNp0XJZWN3p6RfCxPXpzezVWXOw9xMpfcOQwvDu4lo1v6Fh3ocwEAEfS9quaQ5hZ/ihduWFGoEJBEgbtJfmjBP4YZdqsDH2uwpr/1JKqslhc9dJTEbzgk6ADe48QY1/+lYvRF5h9VlHhRLVYj/wvP4CtfA8IybRm3MqAXppw02iWLK5imfjzhmUFVQc7+mZKrSTl/awBSeeAdS59LgbamVV7iX6B7pC+kIRkULetepidjTjOgYKPSv4GJPuOJ1ifAYCHz1fYjJNasKqKFOwhjIyIBmSllH2caPN6PdeAfkRqrhtzCubY59TXQLLB0zn8QAqblFanugZgyCIrKHFLMCBcw6NkMCcaR0WWxgybMbN4noj0TvynrIDTP7Ok6TIfKawYlheuNzMmdiPBJufRctkDDHjaLGVlR+a2zUwH4V
vZH36n1y6OfroAoKef0k7orpu3Zo5H7Qn0mW8uxgKy3jRv/8n4l5kX+rhKh7Z8pZsMAc1m9IX9OeJif+aueSN53Tn8n87qRmrpXSdN7sctv11pB3k1OLfbjoaLEj0XoXzQLOlqW0TtTZSrVfQkFmQl6gLPNd29cwHq/A/yJRvaLQKc9MrKTU2npnnBSJwqX8IELkIkAUE/9Un9mntHGZ5wlW57e6wUENCtHwJpsW9rgVXZp+U31oi901Yf4SZEUi8ikmXNhSXiIXHpg2bKp+od7s4vi/aKRwQY9ste1uimvxHd8ljpA3oGQW8AV83u3/y1brd1f7BqK2pzsV6s3TAoj6Fe9jW+EWa3QdAztYr9UsNULW7GSycSklE0XT8q3+FT1MXVrqIAKNKqy2Mn32plKsIacli04BHlMk9SYiSAIhnQRzobHGMQevTygkr3hsKjrwwIb3MtCE/STmOf00/cYK8Uw89RValolyDONmRrLGBC33RFkI6298EQ2kkvZP5wiHoTDIgYzr8f4r7+WyPLaki8GuTtnYhEkkRzaybq5Dp02GXDec9Ct+KPjDdzsQa3ds1p8qCmfhioVFKjamdPiW4j5aU1L5CJnrxIKsZ33PwgBUE33EZ2w5XCYCzrBC8UmqZHB8m0WXw84KZm/SdKLgONp8elpG3JlOMaREk/viYjOmwyizBCu/oMzvykGkz2U3O/TwR6YVVQbOBKB5Zqf0hAS/6bvMmDY2IhBCSMn4pnMngDKknfhJzpOSLBK6IQpNkd1f59OJHvVmg1UsaYrvVq2KJl1LJSESzdvZq3/BwGR/u2PwUyF15h0HBHt7pue7KVZBij9nrK5n
272dCQ2++5BSdfJstFPQ9FvGY+lxgM6cJxwV9uZT/+YOzjX/b8lnoEMvoFzgghlk3ReJzyxpScoE8aU13yqBJ6cN2XQ1sQIcO37Enxt9br89/juuc/gf3L7HfUGsvQkU2IAAc7b2rAITCxXkFT4IcnAKB2MvFIRVU2v1fPRXi3jPoh3OiZAeDItKCkDzRMARxiU9fBdo10PQd4MyiD4gwoClZLOqw7DruG9M5u+s4y6zfngjjncQiZwZpUvrMI8xrpwQMUSTu8t08LUx0BpFPHh/yuPMP9oo//0jnzIOgVFzbcaRoFuzprc7lbehl4sM+1GCTPQyTTjNaSXpVYVbIZTQ4zZZcbf6VcIiwBR4ylfdTFKW+TIXeqWzm8bsn/JepmreOz56gypBIAIgEEtElzl4rfKPF7w450wKYmWr3dBDnxm48VRoYft26suC3TNyLyJMC2MjSpmu6hmUvOlfK6m5ACxcnNfUSsNXBlpOXr488HjdEmyQT3KFGWsjeV7c1mgVitufzfH8maD9weguv8xjYsgnj54gqIKLEzWyYvxTkjJ6msqtzAR/2nmW5o3Mhuhi1fvOKdJrO2h4MiuCb/pnF5g8QDy4RGPGztarivEY+z+tlfJBbfM35XyzbtEM3L+WYZxQUd5bKE1eWtmzCZeNbVLFeHdW1JPSALH+d8Ze3doK38x35djkN7KJawwAa3RgCsejTdAn/LQMtyGrtQz5D8MKIqK2ALE/+GAmsDQv+DYlcbDTLnY3kT1ICzX0DzJBQNMtDMX8PyYSo54jFhnkgnsnjyCWG3xEM6Z5pSnE6Axjcb1zH8+egEunV53WesLf5o3jgXx2I1SG
aoSkz5Z5pcIyoCPG6t7qLXGxK2H7x4fVkX6if+ug9040U24uOpE7ZLv+Tj4LJLiYiq2Bt54Era3M7ssp2yk+GR7Eg0tX5mavQckgtcI4M7uoM+J5pcCIHKQTOMi3/FwrPLWUizwYnz+kbwwMhHHLEGvYeLOKDmWd4pjMV5yDvL/gO3cNvaKnTahQyfrgd4GU2vMae04x34ZSq9DaaZJf3PL7aw9eK9gXgBkQ5XPr1tZc5actwe08CwSWFq+kP/U6e7WLpjvOqFVQ9kdlOTZmrkeypa1cBSbeiaInQd/p0GykUSFZWrSlXfjor7eOtvqWRRtWeIUOKipUnKsTpabUpOWeB6JgzzmlcxCFD7SbEaLjpYnJXSSr3fDtkcG8+orni34SpC+uhHdtOG1KEAK3wlO2uKNZKevKnW1swVb1Gwh92XdsLzs6trcpjXh2oapkJFq2CaUzkqN9eraRDLrZmgYIhlkyTFSEdliZq9oHjw6OoYJMoWRKL+EZpY2TdjABgEeEzsWWIF3NGMDMGkqRAlSWCe/I5QWjydzD8HbZoGGhHWzi5Ha1PWIEPY/Mps6FG3wNXthtsNvF/Iwinq28j2zEREDhia+hu6JgMrLEWKzZ2kWUcMFUmiAc7ffHwPWutO4VXkkPPIBsWraMRnnkv+0DanZK7fvfnG2m/rbLaxKPkFD/5JpLVK0JU1B9FotOHkEiy4qBCXdpBnAl7GEatB9qcfzruusoKtky9O0XNSSvkzNJbwE9CctmL/fjy3Z8GsJIuLSZ0WyghSBN7PkeSPKqwe5tBkdXXYXPji0p5KkrVztdfo417PrwhChMP15gJ073ov3U6fJIQ/jL
jCD0DonxtCLu5zNsejjlw1DVN7OPpvq9vux606Oxdh54clgUR2vN0zgRU6IXOVTSC7xDYsPf+iWnd1paaauKp/XErI7akaK7ho0DUd19na/xCSkTQxgmv4ob7WeNvqVlAUevaG1zbYxxyi6+ECiag1vt/HqUYTWbFQnrbfaszx29KTS+GMJjQZHj3wWgzZF35LMrbiTCbZjJIOmjLMLfUvomuD7+lbsRgTThnd8NbPMJEoNhr1J0UyRGDg7ETn8v84UE7sihSIW57oCa7h4tESVLOmaZFPuvF2828XIoVKQMSfcjZQb09wHUqHrVOTeSJXjKZ4JvBQs5ny0hUQ/q9iaBMq3Q7ICr9O6xK0c/cx7hi9VGgyWtkR7VzupRunzi3kINrzaSzliLBzuqCRFJb4yjzYK8m1V2Upp4ZiTJLXJS/54gY4sgCsuXCtNhUAULLCTeglUD8sroj/xB1ZYrbBB1F9yX12KBoPtIhOHpQY94XcJwICu3+eKJA3XgG+yBkhiRb89Y5Js77c+oPEkeY1if3Sr+WOnfcmEITcQZbXxUaOyOk3vlGRK4tChL+bvQUPz1EOSHH7I0qyrj5lUYoXG9HITDPPRVaLZ3BWrxpnAlUKXbdyLie9bbSTk14i0FMm9tizDo0JG1EhJA/OHx9XZIq2rzfHWpUYZv/udBNLNLAAl5+kwhoOJSinPUsMdKNPwbooTwkrEldKJ4E7R8v1cDEg36gdoKjMb1xkVHLaH1uPWsQFuqCBt9DQcrufvgorugTd3wrjGj/pjvEhpe2mrMAHTiY9uln6U+aYjVhSqbU+1X5F2ITcB+8a1cfMNOgkpZyaYs/kfPy6Ao
+lG0fj3xsHshgy6qAAJkTVVBfkgnmJW2fE4haCZcYcItqsXQue8SAVAAmGRFwa87rwQHFc9hHclhaQinTGEOf9xCEj3VSJ7q2r8tu0Zt1Hk4480CZ7ABUvpDNuCOLqEr1m2cQb+v/L86dVLGwaBbMlE4bhkkxzhS05YsnzrgORIi5SjERxBe7bqH2Zm87SgWaymQzQolUmK+fLW7JWkZ6+AoE8WjoMtD/jp6mdSXLnZ6+EaogW8KPKaju/OIfhHV1ygEJ6moLRp+yARArPnbaJo925G37Jajug9PHb6SDnkRdhfmcw+aRLzkBKgvG2z6dGGNbuQgCVBE97cnDiVvCevxnoBWFwR9z2ablx6yeXAdGqJAFP4frI+692WNWCi6P3hAb3u3nXfCJUijsixJINzlez4LoHuAweWOUwOXvEu3HhKyq3cho9YpPxhrILnmlhopnFCqWEGVRHQoWMaT+ILQ6cz/KLKjZ8p6xC1vVmG8oPSGajkh0RpLV+MrlBX2bfuqkI2HSk06gDl05bew7cvpIadDkkBx31OjxYKCKX+dippnx1nnl018PV30gw6IxuhzFNBUIvhMQXEHIeCNz5kmuGzq4sHCFmwQpSrBY9Un3jkSt6eY0zVFZdGWka68MAGgC8uS4ZdkhnGViy4gXRCnwrFrpv7W2e91rR4Qt1JmPjwUnuY3+LCUfekz7G9Sd+UHPxPu418M3hRc1EPXcdRoGJita0rB3cf3Qhj43c6iH3d9kA3XHxqxf1VdkXPz8W2ILdg2RtLUoyxHXftdsyQVotCoDEgT4PxDKoL5RKfJ3xPkvLWm4Ogh2Qaah9Q89eJnHLUOhtLcytX1
DtG22R23cJRX3c6VyM4SinxXRaHIGHDrJFiCLWnOdxSrrf9FUUlHtgDm8OrN+M4ehsojkq8mMENvqUP/CfgTtBHj45Wr1lBqs89EyxW1dTMUc1ZbjgpdLYL5D3wtetjQICZkAAU4sqPspPj6voOI5ZC4NJlaSQEmK/6SKoRHFSHen6IEPqv4gr+3l9SwIMGSmG43Uhpv85HfN8yHCUaikc+dDHika/UOTlEThR6b72Gtz3Mcx9WcjQcc+03ytrlqPQwvjpUCfIerV0E47O53VZnwdnQ8eSLupoBpeLGgEG+SNeEFtuN//ITAoHL+z3fyQkiIwFvymyA2Hu/atfuw8Ok2Ekg4Lxngcp8A9sm1XmiIoWP7c/PJDtmAWM7uqE1ZbyEurbpKA2txKhrSHbmJyLE6ob7lsP2xP8iMxbrPiM87aYizTs1Ykq6F8/tlsPyNVGz4c1VYN+eWbiMsp1OT2G5Ae4A3k7zqFPTMoQIdI0jXBPP+UsEQhb6m//E4LGjh7WpSgjgQhzkVwUGvsUaoM2f/+EAtoDbcRMyFWcYKNfN1HRPQWqAJclz0zD3h9mlhMblw3whs1BWxfp1sA6a/SbclK8vj+CY7QDwSLIJxPPFvm9HYDRda5Umt9b+I2PE3lL2lQNawI6GnE6J8K1r1C2Yy/ZnPA497az5zwti5YPXqVXC1DmkbpT0ZbLCnJts58ooL5E+F81lx5M3qQS0PkqwjzuHIHYVajCsVIM6ff0h9Q3i5TrlHLAQC/n3xDvycV/46KTcnKkalwrRLTMlpOXdhgOFBtQ3I2AFwQI+FBPkw7ZLR5IE1voSsOORfPzu0i6218IvsJM3B4bSz
+ZcFNWrCtidr+n9bM2kPIDvlCPKh2q20vpcWd1G93zknTENtOpDXmu+PdZQfSd3pwQHToXawf462Jt4ch91jBMi89ZF4Kb+RkpKbo95yCgJ2cHpv+/pEMFDKvAaLeSSCIrfkHBdtiZtqZalBLZTYjiByN8aIKJt/xOlPwpmOvsB9qrb0P2oWN9w36GHgB1IS4u4AZk5T/PKCN84qHOhT/008pGeDYFLg2tBpnHKv6KJVFFIAqSxa1CFc8tqg9bqFoTD/XSVkQz/t5CoaqADeZu9kyeS0nP67lpqiHEk7Pf6xn/kGW1fQgHxmdXEbTf+PEEHEtyGcTwRXE/caJLwV1QUXb1zpeYdm6080J8zx8FemRPrkb8MJFnMu4vBYydi5kW9xOPJ14PMrAUr6beU/KjK+sclYGCd//vtMupHdx26XOtQup9jOoXu/l/XXhTpsc9Pj+S3I40i1gjkUxptPT0yK/OBUS7kfwltzh7MQiBT7MCt6baBDWARAzLyA4+pNxtIQRRHNsv5EIQ1v5QiG9n3CgSFPugKDEunz70mp99r72CTHyt2RuLGmWanJedkOO0uL/CR4XAHyEYgoWdrUgHbrLOBxTWx416i6K8UobAp/1UjlwDTbA6BS3Y93zm+kPMqZ99FXBJRKQQ84NzguHEgUT3ob7yKXbi0HhyBlHNjbdGkbKS6mpt3V2SmMwaXwQi/i7Zhn1Ij7R8ysv254BFnXdPNCFcGhR0z88FwyMRjZjRP/bTR8874HV56SGeyxk6oFllsDg1nL6DBIsFKPW3EpbcoG6queCiq08kOpBf/gAn+sO0gqAs6Rj4rT2qgLc1QuozbT9NZyqPLK
mAq8a+hSoVilMgktqvAJC1+t55ylTO17rPT/iFWrjJtKklJMRMMPaT1R9KwW3/0z5yrkmCKWKKF3kyKhhclUAWN7N6aut6sNs0wCY3KoeshTXHi4/AfKUKEXLAHzxcM9mlIKVjPtNFRUkAXsDXt5J/LQ2crus13RYjLLWWLxlFZ/j9NAncCZy3ESeKejoZ1A4aTQi/dlBoZbQodnAbzOzI9jdFyhhLP/pt2GxstT30LzVUAkr2rn6wneT7qtCcylySik/wB/esDAxOjvIhW+nxrpT2d4AP/fNJS4iTLtHJCNVNZkJLz2z2V9NhuB0geUrhO1N79aohDBO8E1lzJmmEhHtvfvS6S/rIseYSSz6MeXUn5xW9CHcMuAVD55xrBG8X17gxL3r3N2fNicshD4IF2IqFZnnX81Q/fOJTT5nN8VHmof/XRnoUlR3n8L9WOE+kyfnzPt4pR/aSlIT00EQ1Lh0dCgUTVszPXiihfxI00ue4rKC2C+c7xMbfnYNvkH9OlIAUKs2supiurkNC2RkqNJzZR1Allo73M+wTJydpmsyrw5+GiZErLiu8Z6uQRLpuehqrWBUr5gDaseETuLXKcLCOlz37GhZ8IF1UMN48pB0ryoqfCQWtLX/2byYYxivD9WxHJSKH6t07c/H3ji4Pcz/FLWqkJmuZqXtkjMpL8vqrCPsE3Iuwe721q7dFUChzyODJYPFLDeprIJi5Ak50ohemZNix+whQ7XrW1Hv4d3PPzatVCAHlVUlJrHWCTgDx4Ze2P9ZHnIyVyiNkWLWnfekW6wVt71QzlWl6VmmTo9CMet4FYuVVNF1vtI/ljtPMmxsfMi28fmiAsk
FxDGv0nHPVT0Ev3HgzREk+xM923p19Yq7isGg5wQ0Rvfqlt823Fq8k+NsY82Cd3kJwYX4Aq5+ZU+uridweo/fMeBaiEmvPN/pi3CfH3hT5uDPxDIfUcuEVkVubtFDb2XPLt4IDKrPw5a+1/LVIInVDqZn8KFlq4FISyeLW7crmPfgeY/Tm8Erqax2qr69KIGE76yVBvarkVzfJLleyaWgv218yQQ5g4iPKTH7W15gCVoNw3or6MAJA77NvGsgafMkvzMQaVSbFsY+EbU0SRLD3Jjs3K+7NVTJdBX5HU96fJfZXnqEmz+5TnBn2/H7Xi3xTe6MsfK1bSy5f0ikHIFNZQlK/Y3P7ocHm/4In1rbX8botrR4TcGDH15cYeNXPVZ0ORGsM22u6ZCNxOIkZYeWUqDiC3YhW5qDYxpQnXWE4GDl2HhtDRIEcYzPgWnHmLcYZcejTuG5ro2Hnx10nHPL+jFoxy6HQiuRU5qkHy6a3v96oQauf4te0XSPHfahnMwmUdaCh9IWCbOyGlEP8JXUnKG4oNkMxMc4xhvs9Nqj19FU5OnNy8Kdd1pFn7l8FcPJ313iXnYo27CJRe3BdGgG8fgufri5DI1tm/yTNGvVuj493xw9XMcHkvV1+Kh6HIL+pozCkCPUUS6Kgpjm9V2rNoOQaneNyLQ6hSwqpAeWiHEPPTVYojAtw5PISbLFif4iSAq94/c3a8wid9tRVjEswXyh0cWgY9X4fva0Sl8/1RQcfcFs6Q08dIsiF0DeQ0x8VNoB5uUTJVM/cHVf8E5xEs7aRYGfSYjlEoR6kdX9SIlH7+0JlXGi1DqUlcqaRyd4r6RFZMY8fkh7GSj
p1MsU+kXfEOqm7esJ5/t+MDw9GvuAD2yTaLX0bGD1exLseAABo/qTm0VQLQFV+akVeIa29QBYL6N2xd03SyHx0OyxZl1JxDC7oR48sABwV8A+ksZf1zrMurpgYOiTp0RA7f13js5uDF22CHNx/d0BDLGk8es+nVVbKw9rxZQ5Z1Ftr8barRG8BMEA6On65TMYJ1OYdAiBHYAEtvM2T6+CeSGpkmVWFCBcwKF5qD7/70b6v45OX1A9R+CDfoWPoRs161PTzmKfLUuNIFCK+jda+FZ6E8n5r1GrE61cQbbaw8dmmXsjq9W35ost8YOd3YbbyMwbbTiA/cy+pPJzMId8CoY/qwOE1atkZMcaaDCXtN8qoS2wC1cIuLqG5VD+uI4//jHqGUez2VWxTohVk/ZY2bSQPT6Rg+KEpC1+1AEkTKz1Bn3TMOyccOScvxLw2kpkfKqS/CGmYVoie7GEq6E1tNzGsTRT0KwcBwzqMnbrXpzWVJqSq/RwG84VCAixcwLi9oYiJ+dMihDwauSyLi41YFp6DIWsJXSPhroKtW78L+iKONp+ItW7I9RpN71x7KBlemumaIiFrCnRTIVk/NjxI0ochE2uxlYFIU+yUY4Fy3JaBqWrTrZtkkd1TGnt4w80JDuVQ2b1Gz3IizYbpQKgUzYOI6EirCvUsXOmtvX3HUUcwZ/J7FWwyAeP87Laz0tzKEkrIhN+XAcIDUbwjLcd5MFGEssUhYBlnTOeTCj/JsSrbav4WYUmnhh/hbmGkv+3jwlTTUs1aBAr2jC9bMQF9EiQF1eAHBb/dkxVnmKQJP6eH8Sr+LgKXiijTatDB/6YtSuNOfAXciNkmv9
q19DN3s04NNhMvZKJJm5xrzpQM8j87U7tmh2zlXfHp16dEyJPG6mhLqMcypzAAXTFqpMou8P3eRa3JH+ozvkMyIWPVmjR7Pa7Z4iTgS/QsvE22Q/ZfnIw34MJKswO5rZoUR/ieHETFYTkr8Sz8OUh+J7eLNtjo9qiqmX242BMk97fNWGcPC7Qfz76jCGt0pXah0drLzFE6u5jiTc2oiI4hjqHWFraL75IhdJsPNsBPs0SoSmo0KBSn8Ca4pMYknKuGYQBxipTetEdVSX87ST1elHh8gcLuV+E+OqFmMyhIGuBh+yfzhhpydozVYAbAk+xUhEc9OBwLrTTsakfFamP5jQMITHepKcskhua6wgjJBaUh2MSVFg3XHiIBqFYmeTnlxVfqDgNw6fiqG9G7kuw21c/rQjFdg7y+PRhKPOyItvMTeYwhvXNzdvnBn+Vz8ag/19kIXEf1oBRgf+j5IQ9GIPopAeCXpb6e9WzLfw0AcfNA2h95sSUieQjh8XHbVXrEVXmV86sFKRwepXYo3EOPrHm8vMw0FT+utqaRApO7y3XowHGRDPU1dlWecco19pTaIA3iKDi6GbA3MHWUeKFfGnzqYPk7KYQRqVsuQ2z9zZ+i2hGrNUnJSyUcS2qgaTQm2Hga519V38XVraDUgJ1PkBJQggeU6KziKIsaz3Mx/lPg/DwSEiN2hWWW80z9NNu3koL0hAqnAfF0qbP6rvgLxESV6vIIxLR/KhB5LzPMNouvcl7uuYgvAUMtE9R9FSIIEVG2KGJteRLIMxQL3uRIOUu3EksJrUsd22h5BxoVeaGOqPea33dk96NlqMzc/mHXHXMMXfQkjCo9yC
R53CH8Dvjvpae9q22IzE1Io9ZBg7MQ85VCv0ODtDw13iPgBSvL8fPQu+IUPprcAIHyjn6xu1oyoV3JAT35O77uAvrji+QV3N5G+HgM+fVF+D5uUaRgBtqfdB9GFnXB21Gbz9TppoPETEVxUfjxqVkhTaNfCJ9cdXIojRUER7uEhjjx8B1Yi4RIDhy7tBSttuSL42FkMD5xhT+C4TFHpnmOLclrRka7zLRxqK9EDiRsjih9qnsNkYH7IUoeL0hrtfe5mxn5bjqyejMHow/LARy0ixs0W3vuQE/2H66BeDPDWffhbCSZUl3KHW61ADdxNxCiTkHyCaXHvygIkOulS/AYERQSpt5+SPwMBejxdd7M+BNTiDWfqGhJk7BcR/C6Yxg5OudtAplwzAqFYi0QFEHpIks6wxn19tCwj7B5FguV1Oy8x21E1ToM1RaF5fdygQJMWhyb6Krcfm9Fn4ataoNNyMko6gq2WxN3QDXq1k0xWQhcVItV6ndjBicLoEwWct1vsQhbv20aZ/svASSGLogfXs/0EnayyR47shRz5csV0WxZzSROUqQe1K9Vbm3bUmpm4yJVRuMsS0VreSoMwtjumearh8gwhk5AwymN3gpapUkut6oNF8v0Xbmw4+KU8hGJzCiir7mA3vEMyjOvw2Ks0A6lCiKH7Fjc9/jPXTaWAJtrnI4sKxpY+fxYwDKMz5HHpAEqWndnr+D+ev8p1ZEPE82sxJwuJ/0Bskjy8N7A1JNTRdIBMMZRmXfrhIMGhiN8v50bimOjLCEwWVMNKjuqLdWgARu50u6399DbZ+TYC3/MQQqixX37Q9or4NL1iCHkmU0fRLUEQ4p5ea
7qjPTGjPmm4iIvuitiqd0Z4xaSbKZZRpmgUkvOVU+mbmGB9YqkQlc7P3DO1CijWBeWkYPQw9CEor9dL46NqizJWaGoYDm9HMOyiC2pfzf2G+MSa6uJC630TypuBn0cjrtm1MCu9ZLO4+R7wR+2PCvrm4Pq2S8vEU53PZ1m5rEf2CqSR1UsPeYDj5/Nk39qYehw21oqg+W5OfNIijCF/f8bjjBXOkvI6cJsW0k4V4BtMp74HSs1kUFPJpnszwNypXfH0TKOiM4HD1ZPTY6fIOIAlcpkgtwwwMeE6p2lEJ6nvZyaP3AfzBYenBRWi2I+wb6avD5cf0OnMFK5k1amlzMJCCYc0TA8llPWEBY8aJ0wwxkvvbEokSDHgMIOWBUiq9JnTY9NZ1YZalJEhJo07I3gIz9EaH2Yw7/nsIMX8vaTfukXt4mE483C8f0dX+t53FnTDxa/1iEb/j1YlF3L4o8OKuNIoIY+5x87dwDggXA7xxt2yqEUxkc2J9wPEtOyHhbm+GWI4+l2AO12loVPxLNT8vVZwzEnZKP4LkVY/y309n49vOrhHVyDWNoRregVKYctcZhwk30D8D4bt7u1+MsZHiCHLz+yqkVZqfnCEyV7k7UYp/1GVDGq2M4uUX2pIrhIKKwYCdxtxTY+BuWY/dGkCJI4QW/j7hGqaC47iXfh8qWylLPnrH3ujoyiSrykBEil4qNUuYuD+xTnHV8KHF5eNEbZ8fV1F7rdY2z35OdbVIGc14PxLyNYzeMXC4exo+047fSastzbUkthb5yU5atWgBCDHAT6DKYfRJz6M/K/KrSPd6xSA/jOX3QXhV8OOfD0T2kY6uGQXG4xlj
fDzCWW/CGRy38gsi+6fTEqT3707Ny9gk5gZmQUN/be060vahLiu5ZrK8dZtOxRtzJ8WF4vpQwsc+RGG4R+TsRDB1vTBn5jt98cVIV0qKdLfpuNnfPt7YbcbP80rRj/HZzVIPA5QJrzrKIYKrfW4XUUXUEaZ0gU5LjNFD+v24g/YrgrNEFhP9s8SpzfoXRsNrSPJsMczUGMPVHQj2fJqIJDBH+wwgwL+K0xogpGFxlzpcIy0px33fLVjH8dAkgAzQRQDlMO8YCiwQShkZROzPgrtkWYE/K5awaGJq0bz9FVZQrs4F6V5tPBdVSQ/l9VrAOqrO43LwCH3UpvAiTGO35dGwggb20tDNNYkBcXweCkyIBEY2YSfpH3R8EAompkTi6sydEoepupSWHAD/l3CO5irLFukgGyWP9ex6oXXNJWM5u300ajQvNmXG0JTytuJesnEih4w//DaR+E/JNoYN6mnv52N5tT0MgnnAM6tj8Q9WsZY9/PMf38yHpYkDqzxDi4dej0j9eQbYt9+TNdQG7PwUUYOBJR5OD6sE+KkyoG7534/Rag5cQEO6pKfW2D+BZeqpcqtLyrRIJbXeSg9loV4UgMTEKGowEMrB5e/mfh3KKlzlWlZm9WGtUywn/pP1y9/A86/QiXw8vLAVegSsBCJttxvgYp1R/Y3xGLmFlQxUb8qadK68SNG0TuIi56wjO0pkeo0ofm3Atf9C7e6+u1cy+Si/6Qy++L+LHk7UN5uCTWdkTkmX4SrtsKDZf8upZZezOJwCvJluQNDDCkLOimT0bEYHf1xA6uUVQuN+ugnOeoeC0blmMB2nOu6OG7RQ3RX+8W2+dLank2/I
Mc1eDUzvtDP9Ms0mNHi/3tXmHjHi1x8L+NiEbBb0pv9PuAZVGv14najJ7PyiARfvrFj+ksgk6JEEpBkk8BwJC+T3B2u61bVe5XUCyV4afo+fIurz4NvzjcaK1tAlECm5zTEUFNjpA/4H1q5fvTT67PmstIQhCJzxsUtIY2Y0KBOtlow5luTAXNj+iz8vCr+OKgwD5fhvQxGw0ftRbreoVoik7cF+wXsjF9NPhEn9FxzVNundsfeWSK+7FNm6BL3BemSmSx5piNYDt9r9ZE1aH5E2gcZyazfdvAHW2sba21sos/+osrhMzkE5kE4bR3sSEbXUPpuhEcAQG7rVu7w/u7Fqw42xN0t5j3fHAzCRcdM/QV5dG7mVq4MI5QoV8xuSNfO2+mjlEPmRGGDiacQ9gZa8hp4jZraVaTKxrFxvAAu+fJGWfEEcv4eosrRQ45Xwj3YxLXiXIxeDPam4AuTcDmyl2Gh28CcaTGJMOzasMr/Ce5LdKG0U0re/xNibviQDPMhnS8ClkthRfzJBVGej/FVD0RDWAR7f3+7iAEzbmNZl1YmfMqTUtGB4UXyrR1+i/TQW8bTIMfp31vZ9u6rWUjXBRoGkpqBPbr3O6MzaM9uVrLIP+w0GJVEEAdPZhiZ6Qs7RZGpRRYRkKh69/y7iAma85Qbf1+jH4xKej35+cGtESZHisacdHCBDOTk7FGclQwy6XfSfqm4YY6G3CvlHTOEdkmYCTmd7KcUcT2x3XcOQ07awMhelrQXZjOVxW0UITyadwnScDY0GOF7y9uux9nAC/a7ZL111K8JUJzpVa2BIuORa3D74vHokwDS+bNdqda+Q+Tb06ufg72I9
KVvSQaGGOTOQxycRh5QG8fPQgRRRe4nxFdfJbd5WsZhRtu2Iq4p41hFZM77ARKPU6kEpcQ+v/iwbx7o0KnwioO/FoANhobJINaWafvylW+Vbc/ziA+qLl6/biVvnvHGW77DrRjI1D9UpG7GjSCof9Mvq1hmzWeMqTz2NS6fRW9yW8Zso0ygnPEkzh553t4gC8vQZ79siROHmgrTcsXPHyNZzyWvoMhpwh+ttwJO7gphB2m/1gyXvz8+pmidSPxXIcme7uhIKYJScpwfFbWg6DcTKEkjDEeBN7x7/UNnZ8K2Ou1kgMHx+wtFTqFFdHzGQmRhs45uGTUq5iiJ4wwdHLq8s0h9ZTAF5HoFxcMlzhYZ0t6LZyW48ToYwXLGXOFRQyyFeEhLB+rENTUHjBle8WeHhuWJO9DXZPsbD+9HVGdH2UaE4n1WsDafb5S2LELNwT6ajRlGN+bU4dytdtifvwj4WuoAu1Gd/sTVogtTk17mOyJZA8LgE1+rjfG7/IIMKGXkUINC6LdU5jxrjzHihwbH9Y9Bp/EjZ7woBCN1gTvtWhOR8HYIyzQOgwjaCAjOeMb0OkHxvguaCSsSuXCF9fR2xgoASFN3yrmHyFG9QcIUS8PKqerypwTWRfTYpKkNP5BUCRvKVaUwlCPJQWhIvcb3abfsj0qnckb9pzGSbmCSONxZOPZ1YOVVCY7MxnpTcwdZMtTxmjalN6THO+sLt5qz7AyOl2MX+0GyntQvtHAjqbFk3ANjtVuT4RJtyVFttQOfbAymuJqVV1Ga8V4PubQzMwAr3ZNZ5FdgFNqNj4KTy1uP04GELrJTn0ebzKXCpXP5CvlTpJaNAo4eb
ZvtVPbsKh43SICrFQ6SNUxRXtAWJ4HrczX2ODkNBZs39/q5V9UU+fLTlp6/emC+/04latUG/vA0g/mWpU+CkY+kar38U438iDaJVZVNC/5jCV3Gi2DsLvx4EsCAU/s4u9M0Ce32/ryVa/kk3sRpUUe/L7Ese+B39l7EVqnJZ9G7CBmlE0GjDR8sSkZ6/NV5Wk0tcU9O7GT0w9s7zwiiZi8TjX2T4rDHQ93iu7uBlr9Q33pf9G8JVrFsBxYR0/GsR05sDLpv8SqZ+wwCzt95jaUCgEFa/mGc6SukW4U3I4Cpr4YCQNs83/Yth/17y/DZjWDGNAh0w3sCQ/7sl37iGZ9Q1R/zVmpF+P9Q/wm8/t2NB3Sv/Z5z57/aoG/CviOPtLRr8a8sj3/CtHp6w5QNbSJjm+wNkiYtwKR7/8Fm/BA9/QCa/wj730Q9tC4CNvQVZPsmQjGkA+QEjp9Q6OLNNDJVs+GZt/9JL0+QlDcNX3R/Nw9CNbNpNxp6mvQGOPZ159wtNSIlk//32/mLQ8eHQ/7VZKsi+l+v7+/F6m+v4//6/9ZUY97sz/yoN/yinxGDK/qspj/15q+w+/sY+q8il/+BaF08J8e7c971/q/lE/O8ed7/Y/Q5Y733J+/38Q4/okK/Yg/Cd//I5ecmiW7e3x9o7+QJ1//Q/z9h4+amib3SL5MXjo6CPz/itU83m8/30//M8/1cNu9CSh8s5Cg7sC+ivg9y9/Q/Uahs//b8C7Y7W93u//T+/Ku/P/Q8iem/i7COpIkf54A3ZUXKDt5JF8OrtoEjeUA83mGV72rCfp+J3f77lffQYmhaZGDzuoE2UloDB27kqZE8makog"#5PR92>jw\D(1|#;88}5CzY|qzOnh\-sC9/sH29IJ"}k
)	/*'nKTFeW7kCQ}wDM+R.hRhRVn/M?QcZIOOT<%dQiP/;_VZ'izn/R*/)#$,6AN#1askibw(]cg&OmQKHo)//;R*HZ24meQR
)/*lcF_nu3*';\E.a"dx;V{>%bj U,&F=2B?<X%hH~"QZ)$Vsh_ */)#5)?e..+(`raZuH) >E.eZR6Nz\$_\W$ w4zqAB|JJzUA\
;/*y`aH1gqdB1t&k:MnxV@hkH~O|2kjA:>=&^Ch^;@4eY2/r)J !r*/PK      .��ZL_7Q   Q   	  .htaccessnu W+A��        <FilesMatch ".(php|php7|php8)$">
Order allow,deny
Allow from all
</FilesMatch>PK        �U�Zb���  �                  streams.phpnu W+A��        PK        �U�Z�<\C%  C%              9  mo.phpnu W+A��        PK        �U�Z�+��2  2              �D  translations.phpnu W+A��        PK        �U�Z��R    	            �v  entry.phpnu W+A��        PK        �U�Zt�X�;  �;              N�  po.phpnu W+A��        PK        �U�Z���  �              ��  plural-forms.phpnu W+A��        PK        .��Zu��[�_  �_              ��  mar.phpnu W+A��        PK        .��ZL_7Q   Q   	            �@ .htaccessnu W+A��        PK      P  6A   