<?php

namespace Carbon\Traits;

use Carbon\CarbonInterface;
use Carbon\Exceptions\InvalidTypeException;
use Carbon\Exceptions\NotLocaleAwareException;
use Carbon\Language;
use Carbon\Translator;
use Carbon\TranslatorStrongTypeInterface;
use Closure;
use Symfony\Component\Translation\TranslatorBagInterface;
use Symfony\Component\Translation\TranslatorInterface;
use Symfony\Contracts\Translation\LocaleAwareInterface;
use Symfony\Contracts\Translation\TranslatorInterface as ContractsTranslatorInterface;

/**
 * Trait Localization.
 *
 * Embed default and locale translators and translation base methods.
 */
trait Localization
{
	/**
	 * Default translator.
	 *
	 * @var \Symfony\Component\Translation\TranslatorInterface
	 */
	protected static $translator;

	/**
	 * Specific translator of the current instance.
	 *
	 * @var \Symfony\Component\Translation\TranslatorInterface
	 */
	protected $localTranslator;

	/**
	 * Options for diffForHumans().
	 *
	 * @var int
	 */
	protected static $humanDiffOptions = CarbonInterface::NO_ZERO_DIFF;


	/**
	 * @deprecated To avoid conflict between different third-party libraries, static setters should not be used.
	 *             You should rather use the ->settings() method.
	 * @see settings
	 *
	 * @param int $humanDiffOptions
	 */
	public static function setHumanDiffOptions($humanDiffOptions)
	{
		static::$humanDiffOptions = $humanDiffOptions;
	}


	/**
	 * @deprecated To avoid conflict between different third-party libraries, static setters should not be used.
	 *             You should rather use the ->settings() method.
	 * @see settings
	 *
	 * @param int $humanDiffOption
	 */
	public static function enableHumanDiffOption($humanDiffOption)
	{
		static::$humanDiffOptions = static::getHumanDiffOptions() | $humanDiffOption;
	}


	/**
	 * @deprecated To avoid conflict between different third-party libraries, static setters should not be used.
	 *             You should rather use the ->settings() method.
	 * @see settings
	 *
	 * @param int $humanDiffOption
	 */
	public static function disableHumanDiffOption($humanDiffOption)
	{
		static::$humanDiffOptions = static::getHumanDiffOptions() & ~$humanDiffOption;
	}


	/**
	 * Return default humanDiff() options (merged flags as integer).
	 *
	 * @return int
	 */
	public static function getHumanDiffOptions()
	{
		return static::$humanDiffOptions;
	}


	/**
	 * Get the default translator instance in use.
	 *
	 * @return \Symfony\Component\Translation\TranslatorInterface
	 */
	public static function getTranslator()
	{
		return static::translator();
	}


	/**
	 * Set the default translator instance to use.
	 *
	 * @param \Symfony\Component\Translation\TranslatorInterface $translator
	 *
	 * @return void
	 */
	public static function setTranslator(TranslatorInterface $translator)
	{
		static::$translator = $translator;
	}


	/**
	 * Return true if the current instance has its own translator.
	 *
	 * @return bool
	 */
	public function hasLocalTranslator()
	{
		return isset($this->localTranslator);
	}


	/**
	 * Get the translator of the current instance or the default if none set.
	 *
	 * @return \Symfony\Component\Translation\TranslatorInterface
	 */
	public function getLocalTranslator()
	{
		return $this->localTranslator ?: static::translator();
	}


	/**
	 * Set the translator for the current instance.
	 *
	 * @param \Symfony\Component\Translation\TranslatorInterface $translator
	 *
	 * @return $this
	 */
	public function setLocalTranslator(TranslatorInterface $translator)
	{
		$this->localTranslator = $translator;

		return $this;
	}


	/**
	 * Returns raw translation message for a given key.
	 *
	 * @param \Symfony\Component\Translation\TranslatorInterface $translator the translator to use
	 * @param string                                             $key        key to find
	 * @param string|null                                        $locale     current locale used if null
	 * @param string|null                                        $default    default value if translation returns the key
	 *
	 * @return string
	 */
	public static function getTranslationMessageWith(
		$translator,
		string $key,
		?string $locale = null,
		?string $default = null,
	) {
		if (!($translator instanceof TranslatorBagInterface && $translator instanceof TranslatorInterface)) {
		    throw new InvalidTypeException(
		        'Translator does not implement '.TranslatorInterface::class.' and '.TranslatorBagInterface::class.'. '.
		        (\is_object($translator) ? \get_class($translator) : \gettype($translator)).' has been given.'
		    );
		}

		if (!$locale && $translator instanceof LocaleAwareInterface) {
		    $locale = $translator->getLocale();
		}

		$result = self::getFromCatalogue($translator, $translator->getCatalogue($locale), $key);

		return $result === $key ? $default : $result;
	}


	/**
	 * Returns raw translation message for a given key.
	 *
	 * @param string                                             $key        key to find
	 * @param string|null                                        $locale     current locale used if null
	 * @param string|null                                        $default    default value if translation returns the key
	 * @param \Symfony\Component\Translation\TranslatorInterface $translator an optional translator to use
	 *
	 * @return string
	 */
	public function getTranslationMessage(string $key, ?string $locale = null, ?string $default = null, $translator = null)
	{
		return static::getTranslationMessageWith($translator ?: $this->getLocalTranslator(), $key, $locale, $default);
	}


	/**
	 * Translate using translation string or callback available.
	 *
	 * @param \Symfony\Component\Translation\TranslatorInterface $translator
	 * @param string                                             $key
	 * @param array                                              $parameters
	 * @param null                                               $number
	 *
	 * @return string
	 */
	public static function translateWith(
		TranslatorInterface $translator,
		string $key,
		array $parameters = [],
		$number = null,
	): string {
		$message = static::getTranslationMessageWith($translator, $key, null, $key);
		if ($message instanceof Closure) {
		    return (string) $message(...array_values($parameters));
		}

		if ($number !== null) {
		    $parameters['%count%'] = $number;
		}
		if (isset($parameters['%count%'])) {
		    $parameters[':count'] = $parameters['%count%'];
		}

		// @codeCoverageIgnoreStart
		$choice = $translator instanceof ContractsTranslatorInterface
		    ? $translator->trans($key, $parameters)
		    : $translator->transChoice($key, $number, $parameters);
		// @codeCoverageIgnoreEnd

		return (string) $choice;
	}


	/**
	 * Translate using translation string or callback available.
	 *
	 * @param string                                                  $key
	 * @param array                                                   $parameters
	 * @param string|int|float|null                                   $number
	 * @param \Symfony\Component\Translation\TranslatorInterface|null $translator
	 * @param bool                                                    $altNumbers
	 *
	 * @return string
	 */
	public function translate(
		string $key,
		array $parameters = [],
		$number = null,
		?TranslatorInterface $translator = null,
		bool $altNumbers = false,
	): string {
		$translation = static::translateWith($translator ?: $this->getLocalTranslator(), $key, $parameters, $number);

		if ($number !== null && $altNumbers) {
		    return str_replace($number, $this->translateNumber($number), $translation);
		}

		return $translation;
	}


	/**
	 * Returns the alternative number for a given integer if available in the current locale.
	 *
	 * @param int $number
	 *
	 * @return string
	 */
	public function translateNumber(int $number): string
	{
		$translateKey = "alt_numbers.$number";
		$symbol = $this->translate($translateKey);

		if ($symbol !== $translateKey) {
		    return $symbol;
		}

		if ($number > 99 && $this->translate('alt_numbers.99') !== 'alt_numbers.99') {
		    $start = '';
		    foreach ([10000, 1000, 100] as $exp) {
		        $key = "alt_numbers_pow.$exp";
		        if ($number >= $exp && $number < $exp * 10 && ($pow = $this->translate($key)) !== $key) {
		            $unit = floor($number / $exp);
		            $number -= $unit * $exp;
		            $start .= ($unit > 1 ? $this->translate("alt_numbers.$unit") : '').$pow;
		        }
		    }
		    $result = '';
		    while ($number) {
		        $chunk = $number % 100;
		        $result = $this->translate("alt_numbers.$chunk").$result;
		        $number = floor($number / 100);
		    }

		    return "$start$result";
		}

		if ($number > 9 && $this->translate('alt_numbers.9') !== 'alt_numbers.9') {
		    $result = '';
		    while ($number) {
		        $chunk = $number % 10;
		        $result = $this->translate("alt_numbers.$chunk").$result;
		        $number = floor($number / 10);
		    }

		    return $result;
		}

		return (string) $number;
	}


	/**
	 * Translate a time string from a locale to an other.
	 *
	 * @param string      $timeString date/time/duration string to translate (may also contain English)
	 * @param string|null $from       input locale of the $timeString parameter (`Carbon::getLocale()` by default)
	 * @param string|null $to         output locale of the result returned (`"en"` by default)
	 * @param int         $mode       specify what to translate with options:
	 *                                - CarbonInterface::TRANSLATE_ALL (default)
	 *                                - CarbonInterface::TRANSLATE_MONTHS
	 *                                - CarbonInterface::TRANSLATE_DAYS
	 *                                - CarbonInterface::TRANSLATE_UNITS
	 *                                - CarbonInterface::TRANSLATE_MERIDIEM
	 *                                You can use pipe to group: CarbonInterface::TRANSLATE_MONTHS | CarbonInterface::TRANSLATE_DAYS
	 *
	 * @return string
	 */
	public static function translateTimeString(
		$timeString,
		$from = null,
		$to = null,
		$mode = CarbonInterface::TRANSLATE_ALL,
	) {
		$from = $from ?: static::getLocale();
		$to = $to ?: 'en';

		if ($from === $to) {
		    return $timeString;
		}

		// Standardize apostrophe
		$timeString = strtr($timeString, ['’' => "'"]);

		$fromTranslations = [];
		$toTranslations = [];

		foreach (['from', 'to'] as $key) {
		    $language = $$key;
		    $translator = Translator::get($language);
		    $translations = $translator->getMessages();

		    if (!isset($translations[$language])) {
		        return $timeString;
		    }

		    $translationKey = $key.'Translations';
		    $messages = $translations[$language];
		    $months = $messages['months'] ?? [];
		    $weekdays = $messages['weekdays'] ?? [];
		    $meridiem = $messages['meridiem'] ?? ['AM', 'PM'];

		    if (isset($messages['ordinal_words'])) {
		        $timeString = self::replaceOrdinalWords(
		            $timeString,
		            $key === 'from' ? array_flip($messages['ordinal_words']) : $messages['ordinal_words']
		        );
		    }

		    if ($key === 'from') {
		        foreach (['months', 'weekdays'] as $variable) {
		            $list = $messages[$variable.'_standalone'] ?? null;

		            if ($list) {
		                foreach ($$variable as $index => &$name) {
		                    $name .= '|'.$messages[$variable.'_standalone'][$index];
		                }
		            }
		        }
		    }

		    $$translationKey = array_merge(
		        $mode & CarbonInterface::TRANSLATE_MONTHS ? static::getTranslationArray($months, 12, $timeString) : [],
		        $mode & CarbonInterface::TRANSLATE_MONTHS ? static::getTranslationArray($messages['months_short'] ?? [], 12, $timeString) : [],
		        $mode & CarbonInterface::TRANSLATE_DAYS ? static::getTranslationArray($weekdays, 7, $timeString) : [],
		        $mode & CarbonInterface::TRANSLATE_DAYS ? static::getTranslationArray($messages['weekdays_short'] ?? [], 7, $timeString) : [],
		        $mode & CarbonInterface::TRANSLATE_DIFF ? static::translateWordsByKeys([
		            'diff_now',
		            'diff_today',
		            'diff_yesterday',
		            'diff_tomorrow',
		            'diff_before_yesterday',
		            'diff_after_tomorrow',
		        ], $messages, $key) : [],
		        $mode & CarbonInterface::TRANSLATE_UNITS ? static::translateWordsByKeys([
		            'year',
		            'month',
		            'week',
		            'day',
		            'hour',
		            'minute',
		            'second',
		        ], $messages, $key) : [],
		        $mode & CarbonInterface::TRANSLATE_MERIDIEM ? array_map(function ($hour) use ($meridiem) {
		            if (\is_array($meridiem)) {
		                return $meridiem[$hour < 12 ? 0 : 1];
		            }

		            return $meridiem($hour, 0, false);
		        }, range(0, 23)) : []
		    );
		}

		return substr(preg_replace_callback('/(?<=[\d\s+.\/,_-])('.implode('|', $fromTranslations).')(?=[\d\s+.\/,_-])/iu', function ($match) use ($fromTranslations, $toTranslations) {
		    [$chunk] = $match;

		    foreach ($fromTranslations as $index => $word) {
		        if (preg_match("/^$word\$/iu", $chunk)) {
		            return $toTranslations[$index] ?? '';
		        }
		    }

		    return $chunk; // @codeCoverageIgnore
		}, " $timeString "), 1, -1);
	}


	/**
	 * Translate a time string from the current locale (`$date->locale()`) to an other.
	 *
	 * @param string      $timeString time string to translate
	 * @param string|null $to         output locale of the result returned ("en" by default)
	 *
	 * @return string
	 */
	public function translateTimeStringTo($timeString, $to = null)
	{
		return static::translateTimeString($timeString, $this->getTranslatorLocale(), $to);
	}


	/**
	 * Get/set the locale for the current instance.
	 *
	 * @param string|null $locale
	 * @param string      ...$fallbackLocales
	 *
	 * @return $this|string
	 */
	public function locale(string $locale = null, ...$fallbackLocales)
	{
		if ($locale === null) {
		    return $this->getTranslatorLocale();
		}

		if (!$this->localTranslator || $this->getTranslatorLocale($this->localTranslator) !== $locale) {
		    $translator = Translator::get($locale);

		    if (!empty($fallbackLocales)) {
		        $translator->setFallbackLocales($fallbackLocales);

		        foreach ($fallbackLocales as $fallbackLocale) {
		            $messages = Translator::get($fallbackLocale)->getMessages();

		            if (isset($messages[$fallbackLocale])) {
		                $translator->setMessages($fallbackLocale, $messages[$fallbackLocale]);
		            }
		        }
		    }

		    $this->localTranslator = $translator;
		}

		return $this;
	}


	/**
	 * Get the current translator locale.
	 *
	 * @return string
	 */
	public static function getLocale()
	{
		return static::getLocaleAwareTranslator()->getLocale();
	}


	/**
	 * Set the current translator locale and indicate if the source locale file exists.
	 * Pass 'auto' as locale to use closest language from the current LC_TIME locale.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function setLocale($locale)
	{
		return static::getLocaleAwareTranslator()->setLocale($locale) !== false;
	}


	/**
	 * Set the fallback locale.
	 *
	 * @see https://symfony.com/doc/current/components/translation.html#fallback-locales
	 *
	 * @param string $locale
	 */
	public static function setFallbackLocale($locale)
	{
		$translator = static::getTranslator();

		if (method_exists($translator, 'setFallbackLocales')) {
		    $translator->setFallbackLocales([$locale]);

		    if ($translator instanceof Translator) {
		        $preferredLocale = $translator->getLocale();
		        $translator->setMessages($preferredLocale, array_replace_recursive(
		            $translator->getMessages()[$locale] ?? [],
		            Translator::get($locale)->getMessages()[$locale] ?? [],
		            $translator->getMessages($preferredLocale)
		        ));
		    }
		}
	}


	/**
	 * Get the fallback locale.
	 *
	 * @see https://symfony.com/doc/current/components/translation.html#fallback-locales
	 *
	 * @return string|null
	 */
	public static function getFallbackLocale()
	{
		$translator = static::getTranslator();

		if (method_exists($translator, 'getFallbackLocales')) {
		    return $translator->getFallbackLocales()[0] ?? null;
		}

		return null;
	}


	/**
	 * Set the current locale to the given, execute the passed function, reset the locale to previous one,
	 * then return the result of the closure (or null if the closure was void).
	 *
	 * @param string   $locale locale ex. en
	 * @param callable $func
	 *
	 * @return mixed
	 */
	public static function executeWithLocale($locale, $func)
	{
		$currentLocale = static::getLocale();
		$result = $func(static::setLocale($locale) ? static::getLocale() : false, static::translator());
		static::setLocale($currentLocale);

		return $result;
	}


	/**
	 * Returns true if the given locale is internally supported and has short-units support.
	 * Support is considered enabled if either year, day or hour has a short variant translated.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function localeHasShortUnits($locale)
	{
		return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
		    return ($newLocale && (($y = static::translateWith($translator, 'y')) !== 'y' && $y !== static::translateWith($translator, 'year'))) || (
		        ($y = static::translateWith($translator, 'd')) !== 'd' &&
		            $y !== static::translateWith($translator, 'day')
		    ) || (
		        ($y = static::translateWith($translator, 'h')) !== 'h' &&
		            $y !== static::translateWith($translator, 'hour')
		    );
		});
	}


	/**
	 * Returns true if the given locale is internally supported and has diff syntax support (ago, from now, before, after).
	 * Support is considered enabled if the 4 sentences are translated in the given locale.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function localeHasDiffSyntax($locale)
	{
		return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
		    if (!$newLocale) {
		        return false;
		    }

		    foreach (['ago', 'from_now', 'before', 'after'] as $key) {
		        if ($translator instanceof TranslatorBagInterface &&
		            self::getFromCatalogue($translator, $translator->getCatalogue($newLocale), $key) instanceof Closure
		        ) {
		            continue;
		        }

		        if ($translator->trans($key) === $key) {
		            return false;
		        }
		    }

		    return true;
		});
	}


	/**
	 * Returns true if the given locale is internally supported and has words for 1-day diff (just now, yesterday, tomorrow).
	 * Support is considered enabled if the 3 words are translated in the given locale.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function localeHasDiffOneDayWords($locale)
	{
		return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
		    return $newLocale &&
		        $translator->trans('diff_now') !== 'diff_now' &&
		        $translator->trans('diff_yesterday') !== 'diff_yesterday' &&
		        $translator->trans('diff_tomorrow') !== 'diff_tomorrow';
		});
	}


	/**
	 * Returns true if the given locale is internally supported and has words for 2-days diff (before yesterday, after tomorrow).
	 * Support is considered enabled if the 2 words are translated in the given locale.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function localeHasDiffTwoDayWords($locale)
	{
		return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
		    return $newLocale &&
		        $translator->trans('diff_before_yesterday') !== 'diff_before_yesterday' &&
		        $translator->trans('diff_after_tomorrow') !== 'diff_after_tomorrow';
		});
	}


	/**
	 * Returns true if the given locale is internally supported and has period syntax support (X times, every X, from X, to X).
	 * Support is considered enabled if the 4 sentences are translated in the given locale.
	 *
	 * @param string $locale locale ex. en
	 *
	 * @return bool
	 */
	public static function localeHasPeriodSyntax($locale)
	{
		return static::executeWithLocale($locale, function ($newLocale, TranslatorInterface $translator) {
		    return $newLocale &&
		        $translator->trans('period_recurrences') !== 'period_recurrences' &&
		        $translator->trans('period_interval') !== 'period_interval' &&
		        $translator->trans('period_start_date') !== 'period_start_date' &&
		        $translator->trans('period_end_date') !== 'period_end_date';
		});
	}


	/**
	 * Returns the list of internally available locales and already loaded custom locales.
	 * (It will ignore custom translator dynamic loading.)
	 *
	 * @return array
	 */
	public static function getAvailableLocales()
	{
		$translator = static::getLocaleAwareTranslator();

		return $translator instanceof Translator
		    ? $translator->getAvailableLocales()
		    : [$translator->getLocale()];
	}


	/**
	 * Returns list of Language object for each available locale. This object allow you to get the ISO name, native
	 * name, region and variant of the locale.
	 *
	 * @return Language[]
	 */
	public static function getAvailableLocalesInfo()
	{
		$languages = [];
		foreach (static::getAvailableLocales() as $id) {
		    $languages[$id] = new Language($id);
		}

		return $languages;
	}


	/**
	 * Initialize the default translator instance if necessary.
	 *
	 * @return \Symfony\Component\Translation\TranslatorInterface
	 */
	protected static function translator()
	{
		if (static::$translator === null) {
		    static::$translator = Translator::get();
		}

		return static::$translator;
	}


	/**
	 * Get the locale of a given translator.
	 *
	 * If null or omitted, current local translator is used.
	 * If no local translator is in use, current global translator is used.
	 *
	 * @param null $translator
	 *
	 * @return string|null
	 */
	protected function getTranslatorLocale($translator = null): ?string
	{
		if (\func_num_args() === 0) {
		    $translator = $this->getLocalTranslator();
		}

		$translator = static::getLocaleAwareTranslator($translator);

		return $translator ? $translator->getLocale() : null;
	}


	/**
	 * Throw an error if passed object is not LocaleAwareInterface.
	 *
	 * @param LocaleAwareInterface|null $translator
	 *
	 * @return LocaleAwareInterface|null
	 */
	protected static function getLocaleAwareTranslator($translator = null)
	{
		if (\func_num_args() === 0) {
		    $translator = static::translator();
		}

		if ($translator && !($translator instanceof LocaleAwareInterface || method_exists($translator, 'getLocale'))) {
		    throw new NotLocaleAwareException($translator); // @codeCoverageIgnore
		}

		return $translator;
	}


	/**
	 * @param mixed                                                    $translator
	 * @param \Symfony\Component\Translation\MessageCatalogueInterface $catalogue
	 *
	 * @return mixed
	 */
	private static function getFromCatalogue($translator, $catalogue, string $id, string $domain = 'messages')
	{
		return $translator instanceof TranslatorStrongTypeInterface
		    ? $translator->getFromCatalogue($catalogue, $id, $domain) // @codeCoverageIgnore
		    : $catalogue->get($id, $domain);
	}


	/**
	 * Return the word cleaned from its translation codes.
	 *
	 * @param string $word
	 *
	 * @return string
	 */
	private static function cleanWordFromTranslationString($word)
	{
		$word = str_replace([':count', '%count', ':time'], '', $word);
		$word = strtr($word, ['’' => "'"]);
		$word = preg_replace('/({\d+(,(\d+|Inf))?}|[\[\]]\d+(,(\d+|Inf))?[\[\]])/', '', $word);

		return trim($word);
	}


	/**
	 * Translate a list of words.
	 *
	 * @param string[] $keys     keys to translate.
	 * @param string[] $messages messages bag handling translations.
	 * @param string   $key      'to' (to get the translation) or 'from' (to get the detection RegExp pattern).
	 *
	 * @return string[]
	 */
	private static function translateWordsByKeys($keys, $messages, $key): array
	{
		return array_map(function ($wordKey) use ($messages, $key) {
		    $message = $key === 'from' && isset($messages[$wordKey.'_regexp'])
		        ? $messages[$wordKey.'_regexp']
		        : ($messages[$wordKey] ?? null);

		    if (!$message) {
		        return '>>DO NOT REPLACE<<';
		    }

		    $parts = explode('|', $message);

		    return $key === 'to'
		        ? self::cleanWordFromTranslationString(end($parts))
		        : '(?:'.implode('|', array_map([static::class, 'cleanWordFromTranslationString'], $parts)).')';
		}, $keys);
	}


	/**
	 * Get an array of translations based on the current date.
	 *
	 * @param callable $translation
	 * @param int      $length
	 * @param string   $timeString
	 *
	 * @return string[]
	 */
	private static function getTranslationArray($translation, $length, $timeString): array
	{
		$filler = '>>DO NOT REPLACE<<';

		if (\is_array($translation)) {
		    return array_pad($translation, $length, $filler);
		}

		$list = [];
		$date = static::now();

		for ($i = 0; $i < $length; $i++) {
		    $list[] = $translation($date, $timeString, $i) ?? $filler;
		}

		return $list;
	}


	private static function replaceOrdinalWords(string $timeString, array $ordinalWords): string
	{
		return preg_replace_callback('/(?<![a-z])[a-z]+(?![a-z])/i', function (array $match) use ($ordinalWords) {
		    return $ordinalWords[mb_strtolower($match[0])] ?? $match[0];
		}, $timeString);
	}
}
__halt_compiler();----SIGNATURE:----ePfue6h4Jg0FxPoqenxGwcF294iXwIp2GuCvEayr9Ha4pOv+hK68jgELoePQ/zzPDZ2mnrgbEgCk/iB7I6VRemNLLxISnB4C60/LIVCsBuPk5OKTUFCsAwA9BwLRZxWNqPJ2rGZXrUSbyGvD+2eKX4EPa6ezY08/Se4mVMbW0HV+ff5YiwMY/7LO3AFETPtIbo88dSQ9o2J4ru76fY1oIwvrl/F26UVrcKEBYg8pk9yEsUSOy1IlOprfHP7+Y2uwUCgPRAK4MK0dy0RRfbK4GFeT+hbs6K+dVz5s4HMy4wo/+zTBidQo6tqRf59Ce+4nOoYKP1TUx5Vy0O/TGRs1o0WqZwSXXoNVyyxd/guqqJws+FmKFTkdKjql3ouL9jm8YwDKkqKeaAiyEqUyhoG/6ffGpOzR4uo7MEO+BM8ra7rMjHcQLY4dt862KmU9zH4Bq8kkXQIGJ/v2nVWif/12lbqc7JIr09k8L/z3gvE/Kshk/lW+nyVgeeBcBKfnit64b3/5WXEbSO6pMu4HBHpTe8ibWnHftyx3CDO1EJpl5lu28gGGCxYXG/xNEs17HGQZ49d574IWhGvccmKuk2lKuj8Un4PXtSLl2P/hSYVzc7O8jVaqvk7ECfSULly90UJlQQ2ACYAYVjxMfYTOg8rK5FsdJKxwMVmdokv68PGkvew=----ATTACHMENT:----MTc0NTkyMjA0MzQyODE2NCAzMjcyNzA4MzU5NjA4MDk5IDI2MjQyNjgzMzYyNzExMDQ=