<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
<!-- Copyright © 1991-2025 Unicode, Inc.
For terms of use, see http://www.unicode.org/copyright.html
SPDX-License-Identifier: Unicode-3.0
CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
-->
<ldml>
	<identity>
		<version number="$Revision$"/>
		<language type="nqo"/>
	</identity>
	<localeDisplayNames>
		<localeDisplayPattern>
			<localeSeparator>{0}، {1}</localeSeparator>
		</localeDisplayPattern>
		<languages>
			<language type="af">ߊߝߙߌߞߊ߲߯ߛߑߞߊ߲</language>
			<language type="agq">ߊߜ߭ߍߡߑߞߊ߲</language>
			<language type="ak">ߊߞߊ߲ߞߊ</language>
			<language type="am">ߊߡߑߤߊߙߌ</language>
			<language type="ar">ߊߙߓߎߞߊ߲</language>
			<language type="ar_001">ߊߙߊߓߎߞߊ߲ ߘߐߞߣߍߣߍ߲</language>
			<language type="as">ߊߛߊߡߍߞߊ߲</language>
			<language type="asa">ߊߖ߭ߎߞߊ߲</language>
			<language type="ast">ߊߛߑߕߎߙߌߞߊ߲</language>
			<language type="az">ߊߖߍߙߑߓߊߦߌߖߊߞߊ߲</language>
			<language type="az" alt="short">ߊߖߋߙߌߞߊ߲</language>
			<language type="bal">ߓߊߟߎߗߌߞߊ߲</language>
			<language type="bas">ߓߛߊߞߊ߲</language>
			<language type="be">ߓߌߟߏߙߎ߳ߛߌߞߊ߲</language>
			<language type="bem">ߓߋ߲ߓߊߞߊ߲</language>
			<language type="bew">ߓߋߕߊߥߌߞߊ߲</language>
			<language type="bez">ߓߋߣߊߞߊ߲</language>
			<language type="bg">ߓߌߟߑߜ߭ߊߙߌߞߊ߲</language>
			<language type="blo">ߊߣߌ߯ߞߊ߲</language>
			<language type="bm">ߒߞߏ ߡߊߟߌ</language>
			<language type="bn">ߓߍ߲ߜ߭ߊߟߌߞߊ߲</language>
			<language type="bo">ߕߌߓߋߕߌߞߊ߲</language>
			<language type="br">ߓߙߋߕߐ߲ߞߊ߲</language>
			<language type="brx">ߓߏߘߏߞߊ߲</language>
			<language type="bs">ߓߐߛߑߣߌߞߊ߲</language>
			<language type="ca">ߞߕߊߟߊ߲ߞߊ߲</language>
			<language type="ccp">ߞߏߘߊ߫ ߗߊߜ߭ߑߡߊߞߊ߲</language>
			<language type="ce">ߗߋߗߋߣߌߞߊ߲</language>
			<language type="ceb">ߛߋߓߎߥߊߞߊ߲</language>
			<language type="cgg">ߞߌߜ߭ߊߞߊ߲</language>
			<language type="chr">ߗߋߙߏߞߌߞߊ߲</language>
			<language type="ckb">ߛߏߙߊߣߌߞߊ߲</language>
			<language type="ckb" alt="menu">ߛߏߙߊߣߌ߫ ߞߎߙߑߘߎߞߊ߲</language>
			<language type="co">ߞߐߙߑߛߌߞߊ߲</language>
			<language type="cs">ߗߍߞߌߞߊ߲</language>
			<language type="cu">ߛߌߟߊߝ߭ߐ߲ߞߊ߲ ߓߊ߬ߕߏ߬ߓߏ߲߬ߞߊ߲</language>
			<language type="cy">ߜ߭ߟߏߥߊߞߊ߲</language>
			<language type="da">ߘߊߣߏߥߊߞߊ߲</language>
			<language type="dav">ߕߊߦߌߕߊߞߊ߲</language>
			<language type="de">ߊߟߑߡߊ߲ߞߊ߲</language>
			<language type="de_AT">ߏߕߑߙߌߛߌ߬ ߊߟߑߡߊߞߊ߲</language>
			<language type="de_CH">ߛߥߌߛ ߊߟߑߡߊ߲ߞߊ߲</language>
			<language type="dje">ߖ߭ߍߙߑߡߊߞߊ߲</language>
			<language type="doi">ߘߏߜ߭ߙߌߞߊ߲</language>
			<language type="dsb">ߛߏߙߊߓ-ߓߊߛߑߞߊ߲</language>
			<language type="dua">ߘߎߥߟߊߞߊ߲</language>
			<language type="dyo">ߝߐߢߌ߫ ߖߏ߬ߟߊ߬ߞߊ߲</language>
			<language type="dz">ߖ߭ߏ߲ߜ߭ߊߞߊ߲</language>
			<language type="ebu">ߋ߲ߓߎߞߊ߲</language>
			<language type="ee">ߋߥߋߞߊ߲</language>
			<language type="el">ߜ߭ߙߍ߬ߞߌ߬ߞߊ߲</language>
			<language type="en">ߊ߲߬ߜߑߟߋ߬ߞߊ߲</language>
			<language type="en_AU">ߐߛߑߕߙߊߟߌ߫ ߊ߲߬ߜ߭ߑߟߋ߬ߞߊ߲</language>
			<language type="en_CA">ߞߣߊߘߊ߫ ߊ߲߬ߜ߭ߑߟߋ߬ߞߊ߲</language>
			<language type="en_GB">ߓߙߌߕߊ߲ߓߊ߫ ߊ߲߬ߜ߭ߑߟߋ߬ߞߊ߲</language>
			<language type="en_GB" alt="short">ߡ.ߟ. ߊ߲߬ߜ߭ߑߟߋ߲߬ߞߊ߲</language>
			<language type="en_US">ߊߡߋߙߌߞߌ߬ ߊ߲߬ߜ߭ߑߟߋ߬ߞߊ߲</language>
			<language type="en_US" alt="short">ߞ.ߘ. ߊ߲߬ߜ߭ߑߟߋ߬ߞߊ߲</language>
			<language type="eo">ߍߛߑߔߋߙߊ߲ߕߏߞߊ߲</language>
			<language type="es">ߊߛߌߔߞߊ߲</language>
			<language type="es_419">ߊߡߋߙߌߞߌ߬ ߊߛߌߔߊ߲ߞߊ߲ ߟߊ߬ߕߍ߬ߡߊ</language>
			<language type="es_ES">ߊߛߌߔߊ߲߫ ߊߛߌߔߊ߲ߞߊ߲</language>
			<language type="es_MX">ߡߍߞߑߛߌߞ ߊߛߌߔߊ߲ߞߊ߲</language>
			<language type="et">ߍߛߑߕߏߣߌߞߊ߲</language>
			<language type="eu">ߓߊߛߑߞߌߞߊ߲</language>
			<language type="ewo">ߋߥߏ߲ߘߏߞߊ߲</language>
			<language type="fa">ߝߊ߯ߙߛߌߞߊ߲</language>
			<language type="fa_AF">ߘߊߙߌߞߊ߲</language>
			<language type="ff">ߝߎߟߊߞߊ߲</language>
			<language type="fi">ߝߍߣߏߥߊߞߊ߲</language>
			<language type="fil">ߝߟߌߔߌ߲ߞߊ߲</language>
			<language type="fo">ߝߋߙߏߞߊ</language>
			<language type="fr">ߝߊ߬ߙߊ߲߬ߛߌ߬ߞߊ߲</language>
			<language type="fr_CA">ߞߣߊߘߊ߫ ߝߊ߬ߙߊ߲߬ߛߌ߬ߞߊ߲</language>
			<language type="fr_CH">ߛߥߌߛ ߝߙߊ߬ߛߌ߬ߞߊ߲</language>
			<language type="frc">ߞߊߘߌ߫ ߝߊ߬ߙߊ߲߬ߛߌ߬ߞߊ߲</language>
			<language type="fur">ߝߙߌߥߎߟߊߞߊ߲</language>
			<language type="fy">ߕߟߋ߬ߓߋ ߝߙߌߛߐ߲ߞߊ߲</language>
			<language type="ga">ߌߙߑߟߊ߲ߘߌߞߊ߲</language>
			<language type="gd">ߋߞߐߛߌ߬ ߖ߭ߋߏߟߌߞߊ߲</language>
			<language type="gl">ߜ߭ߊߟߌߛߌߞߊ߲</language>
			<language type="gsw">ߛߥߌߛߌ߬ ߊߟߑߡߊ߲ߞߊ߲</language>
			<language type="gu">ߜ߭ߎߖߙߊߞߊ߲</language>
			<language type="guz">ߜߎ߭ߛߌߞߊ߲</language>
			<language type="gv">ߡߊߣߏߥߊߞߊ߲</language>
			<language type="ha">ߤߊߥߎߛߊߞߊ߲</language>
			<language type="haw">ߤߥߊߦߌߞߊ߲</language>
			<language type="he">ߋߓߙߋߞߊ߲</language>
			<language type="hi">ߍ߲ߘߎߞߊ߲</language>
			<language type="hmn">ߡߐ߲ߜ߭ߑߞߊ߲</language>
			<language type="hr">ߞߙߏߥߊߛߌߞߊ߲</language>
			<language type="hsb">ߛߏߙߊߓߎ߫ ߛߊ߲ߘߐ߫ ߞߊ߲</language>
			<language type="ht">ߤߊߦߌߕߌ߫ ߕߊ߬ߓߎ߰ߛߌ߬ߞߊ߲</language>
			<language type="hu">ߤߐ߲ߜ߭ߙߌߞߊ߲</language>
			<language type="hy">ߊߙߊߡߋߣߌߞߊ߲</language>
			<language type="ia">ߍ߲ߕߍߙߑߟߌ߲ߜ߭ߏߥߊߞߊ߲</language>
			<language type="id">ߍ߲ߘߣߏߛߌߞߊ߲</language>
			<language type="ig">ߊߜߏߞߊ߲</language>
			<language type="ii">ߛߌߛߎߥߊ߲߫ ߦߌߞߊ߲</language>
			<language type="is">ߌߛߑߟߊ߲ߘߌߞߊ߲</language>
			<language type="it">ߌߕߊߟߌߞߊ߲</language>
			<language type="ja">ߖ߭ߊߔߐ߲ߞߊ߲</language>
			<language type="jgo">ߒߜ߭ߏ߲ߓߊߞߊ߲</language>
			<language type="jmc">ߡߊߗߊߡߋߞߊ߲</language>
			<language type="jv">ߖ߭ߝ߭ߊߣߊߞߊ߲</language>
			<language type="ka">ߖ߭ߋߐߙߑߖ߭ߌߞߊ߲</language>
			<language type="kab">ߞߊߓߟߌߞߊ߲</language>
			<language type="kam">ߞߊ߲ߓߊߞߊ߲</language>
			<language type="kde">ߡߊߞߐ߲ߘߋߞߊ߲</language>
			<language type="kea">ߜߙߋߞߎ߲ߝߙߌߛߌߞߊ߲</language>
			<language type="kgp">ߞߍ߲ߜ߭ߊ߲ߞߊ߲</language>
			<language type="khq">ߞߏߙߌߦߊߗߣߌߞߊ߲</language>
			<language type="ki">ߞߌߞߌߦߎߞߊ߲</language>
			<language type="kk">ߞߖ߭ߊߞߌߞߊ߲</language>
			<language type="kkj">ߞߊߞߏߞߊ߲</language>
			<language type="kl">ߜ߭ߙߏߟߊ߲ߘߌߞߊ߲</language>
			<language type="kln">ߞߊߟߊ߲ߖߌߞߊ߲</language>
			<language type="km">ߞߑߡߍߙߑߞߊ߲</language>
			<language type="kn">ߞߊ߲ߣߊߘߊߞߊ߲</language>
			<language type="ko">ߞߏߙߋߞߊ߲</language>
			<language type="kok">ߞߐ߲ߞߊߣߌߞߊ߲</language>
			<language type="ks">ߞߊߛߑߡߙߌߞߊ߲</language>
			<language type="ksb">ߛߊ߲ߓߟߊߞߊ߲</language>
			<language type="ksf">ߓߊߝߌߞߊ߲</language>
			<language type="ksh">ߞߐߟߑߗߌߞߊ߲</language>
			<language type="ku">ߞߎߙߑߘߎߞߊ߲</language>
			<language type="kw">ߞߐߙߑߣߌߞߌߞߊ߲</language>
			<language type="ky">ߞߌߙߑߞߌߖ߭ߑߞߊ߲</language>
			<language type="la">ߟߊ߬ߕߍ߲߬ߞߊ߲</language>
			<language type="lag">ߟߊ߲ߖߌߞߊ߲</language>
			<language type="lb">ߟߎߞߑߛߊ߲ߓߎ߯ߙߎߞߊ߲</language>
			<language type="lg">ߜ߭ߊ߲ߘߊߞߊ߲</language>
			<language type="lij">ߟߌ߭ߎ߳ߙߌߞߊ߲</language>
			<language type="lkt">ߟߊߞߏߕߊߞߊ߲</language>
			<language type="ln">ߟߌ߲ߜ߭ߟߊߞߊ߲</language>
			<language type="lo">ߟߊߏߞߊ߲</language>
			<language type="lou">ߟߌߖ߭ߌߦߊߣߌ߫ ߕߊ߬ߓߎ߰ߛߌ߬ߞߊ߲</language>
			<language type="lrc">ߕߟߋ߬ߓߐ ߟߏߙߌߞߊ߲</language>
			<language type="lt">ߟߌߕߎ߳ߦߊߣߌߞߊ߲</language>
			<language type="lu">ߞߊߕߊ߲ߜ߭ߊ߫-ߗߌ߬ߟߎ߬ߓߊ߬ߞߊ߲</language>
			<language type="luo">ߟߎ߳ߏߞߊ߲</language>
			<language type="luy">ߟߎ߳ߦߌߞߊ߲</language>
			<language type="lv">ߟߋߕߐ߲ߞߊ߲</language>
			<language type="mai">ߡߊߗߟߌߞߊ߲</language>
			<language type="mas">ߡߊ߯ߛߊߞߊ߲</language>
			<language type="mer">ߡߋߙߎߞߊ߲</language>
			<language type="mfe">ߡߏߙߌߛ ߕߊ߬ߓߎ߰ߛߌ߬ߞߊ߲</language>
			<language type="mg">ߡߊߟߑߜ߭ߊߛߌߞߊ߲</language>
			<language type="mgh">ߡߊߞߎߞߊ߲</language>
			<language type="mgo">ߡߋߕߊߞߊ߲</language>
			<language type="mi">ߡߊߏߙߌߞߊ߲</language>
			<language type="mk">ߡߊߛߋߘߏߣߌߞߊ߲</language>
			<language type="ml">ߡߟߊߦߟߊߡߑߞߊ߲</language>
			<language type="mn">ߡߐ߲ߜ߭ߐߟߌߞߊ߲</language>
			<language type="mni">ߡߊߣߌߔߎߙߌߞߊ߲</language>
			<language type="mr">ߡߙߊߕߌߞߊ߲</language>
			<language type="ms">ߡߊߟߍߞߊ߲</language>
			<language type="mt">ߡߊߟߑߕߍߞߊ߲</language>
			<language type="mua">ߡߎ߲ߘߊ߲ߞߊ߲</language>
			<language type="mul">ߞߊ߲ߥߙߍߞߊ߲</language>
			<language type="my">ߓߙߌߡߊ߲ߞߊ߲</language>
			<language type="mzn">ߡߊߖ߭ߊ߲ߘߋߙߊߣߞߊ߲</language>
			<language type="naq">ߣߡߊߞߊ߲</language>
			<language type="nb">ߣߐߙߑߝ߭ߍߖ߭ ߓߏߞߑߡߊߟߑߞߊ߲</language>
			<language type="nd">ߕߟߋ߬ߓߐ ߒߘߓߋߟߋߞߊ߲</language>
			<language type="nds">ߊߟߑߡߊ߲ߘߎ߯-ߓߊߛߑߞߊ߲</language>
			<language type="nds_NL">ߤߏߟߊ߲ߘߌ߬ ߓߊߛߊߞߑߛߐ߲ߞߊ߲</language>
			<language type="ne">ߣߋߔߌߟߌߞߊ߲</language>
			<language type="nl">ߣߍ߯ߙߑߟߊ߲ߘߌߞߊ߲</language>
			<language type="nl_BE">ߝߌߟߊߡߊ߲ߞߊ߲</language>
			<language type="nmg">ߒߜ߭ߎ߲ߓߊߞߊ߲</language>
			<language type="nn">ߣߐߙߑߝ߭ߍߖ߭ ߢߙߐߛߌߞߊ߲</language>
			<language type="nnh">ߒߖߋ߲ߓߎ߲ߞߊ߲</language>
			<language type="no">ߣߐߙߑߝ߭ߍߖ߭ߌߞߊ߲</language>
			<language type="nqo">ߒߞߏ</language>
			<language type="nus">ߣߎߦߋߞߊ߲</language>
			<language type="nv">ߣߝ߭ߊߖߏߞߊ߲</language>
			<language type="ny">ߛߋߥߞߊ߲</language>
			<language type="nyn">ߢߊ߲ߞߏߟߋߞߊ߲</language>
			<language type="om">ߏߙߏߡߏߞߊ߲</language>
			<language type="or">ߏߖߊߞߊ߲</language>
			<language type="os">ߏߛߍߕߌߞߊ߲</language>
			<language type="pa">ߔߍ߲ߖߊߓߌߞߊ߲</language>
			<language type="pap">ߔߊߔߌߦߊߡߊ߲ߕߏߞߊ߲</language>
			<language type="pcm">ߖߋ߬ߟߌ߬ߓߊߟߊ߫ ߔߌߘߑߜ߭ߍ߲ߞߊ߲</language>
			<language type="pl">ߔߟߏߣߍߞߊ߲</language>
			<language type="prg">ߔߎߙߛߌߞߊ߲</language>
			<language type="ps">ߔߊߛߑߕߏߞߊ߲</language>
			<language type="pt">ߔߕߏ߬ߞߌ߬ߞߊ߲</language>
			<language type="pt_BR">ߓߙߋߖ߭ߌߟ ߔߕߏ߬ߞߌ߬ߞߊ߲</language>
			<language type="pt_PT">ߋߙߐߔߎ߬ ߔߕߏ߬ߞߌ߬ߞߊ߲</language>
			<language type="qu">ߞߋߛߎߥߊߞߊ߲</language>
			<language type="rhg">ߙߏߤߌ߲ߜ߭ߊ</language>
			<language type="rm">ߙߏߡߊ߲ߛߌߞߊ߲</language>
			<language type="rn">ߙߎ߲ߘߌߞߊ߲</language>
			<language type="ro">ߙߏߡߍߞߊ߲</language>
			<language type="ro_MD">ߡߐߟߑߘߊߝ߭ߌߞߊ߲</language>
			<language type="rof">ߙߏ߲ߓߏߞߊ߲</language>
			<language type="ru">ߌ߬ߙߛߌ߬ߞߊ߲</language>
			<language type="rw">ߞߌ߲ߦߊߙߎߥߊ߲ߘߊߞߊ߲</language>
			<language type="rwk">ߙߥߊߞߊ߲</language>
			<language type="sa">ߛߊߛߑߞߙߌߞߊ߲</language>
			<language type="sah">ߌߦߊߞߎߕߌߞߊ߲</language>
			<language type="saq">ߛߊ߲ߓߙߎߞߊ߲</language>
			<language type="sat">ߛߊ߲ߕߊߟߌߞߊ߲</language>
			<language type="sbp">ߌߛߊ߲ߜ߭ߎߞߊ߲</language>
			<language type="scn">ߛߌߛߟߌߦߊߞߊ߲</language>
			<language type="sd">ߛߌ߲ߘߌߞߊ߲</language>
			<language type="se">ߛߋߡߌ߫ ߕߟߋ߬ߓߐ߬ߞߊ߲</language>
			<language type="seh">ߛߌߛߋߣߊߞߊ߲</language>
			<language type="ses">ߞߏߦߌߙߊߓߙߏ߫ ߛߋߣߌߞߊ߲</language>
			<language type="sg">ߛߊ߲ߜߵߏߞߊ߲</language>
			<language type="shi">ߗߑߟߋߥߎߞߊ߲</language>
			<language type="si">ߛߌ߲ߜ߭ߟߊߞߊ߲</language>
			<language type="sk">ߛߑߟߏߝ߭ߊߞߌߞߊ߲</language>
			<language type="sl">ߛߑߟߏߝ߭ߋߣߌߞߊ߲</language>
			<language type="sm">ߛߊߡߏߥߊߞߊ߲</language>
			<language type="smn">ߌߣߊߙߌ߫ ߛߊߡߌߞߊ߲</language>
			<language type="sn">ߛߏߣߊߞߊ߲</language>
			<language type="so">ߛߏߡߊߟߌߞߊ߲</language>
			<language type="sq">ߊߟߑߓߊߣߌߞߊ߲</language>
			<language type="sr">ߛߍߙߑߓߌߞߊ߲</language>
			<language type="st">ߛߕߏ߫ ߥߙߏ߬ߘߎ߰ߞߊ߲</language>
			<language type="su">ߛߎ߲ߘߣߊߞߊ߲</language>
			<language type="sv">ߛߎߥߍߘߌߞߊ߲</language>
			<language type="sw">ߛߎߥߊߤߟߌߞߊ߲</language>
			<language type="ta">ߕߊߡߎߟߌߞߊ߲</language>
			<language type="te">ߕߋߟߎߜ߭ߎߞߊ߲</language>
			<language type="teo">ߕߋߛߏߞߊ߲</language>
			<language type="tg">ߕߊߖߞߌߞߊ߲</language>
			<language type="th">ߕߊߦߌߞߊ߲</language>
			<language type="ti">ߕߜ߭ߌߙߌߢߊߞߊ߲</language>
			<language type="tig">ߕߌߜ߭ߙߋߞߊ߲</language>
			<language type="tk">ߕߎߙߞߌߡߍߣߌߞߊ߲</language>
			<language type="to">ߕߏ߲ߖ߭ߌߞߊ߲</language>
			<language type="tr">ߕߙߎߞߌߞߊ߲</language>
			<language type="tt">ߕߊߕߊߙߌߞߊ߲</language>
			<language type="twq">ߕߛߊߥߊߜ߭ߌߞߊ߲</language>
			<language type="tzm">ߊߕߌߟߊ߲ߕߊ߫ ߕߊ߲ߓߊ߲ ߊߡߊ߲ߖ߭ߌ߲ߞߊ߲</language>
			<language type="ug">ߥߌߜ߭ߎ߯ߙߎߞߊ߲</language>
			<language type="uk">ߎߞߌߙߍߣߌߞߊ߲</language>
			<language type="und">ߞߊ߲߫ ߘߊ߲߬ߠߊ߬ߕߍ߰ߓߊߟߌ</language>
			<language type="ur">ߎߙߘߎߞߊ߲</language>
			<language type="uz">ߎߖ߭ߑߓߋߞߌߞߊ߲</language>
			<language type="vai">ߒߝ߭ߊߦߌ߲ߞߊ߲</language>
			<language type="vec">ߝ߭ߣߋߛߌߦߊߞߊ߲</language>
			<language type="vi">ߝ߭ߌߦߋߕߌߣߊߡߌߞߊ߲</language>
			<language type="vo">ߝ߭ߏߟߊߔߎߞߊ߲</language>
			<language type="vun">ߝ߭ߎߖߏߞߊ߲</language>
			<language type="wae">ߥߊߟߑߛߍߙߌߞߊ߲</language>
			<language type="wo">ߥߟߐߝߐߞߊ߲</language>
			<language type="xh">ߛߏߖ߭ߊߞߊ߲</language>
			<language type="xog">ߛߏߜ߭ߊߞߊ߲</language>
			<language type="yav">ߦߊ߲ߜߌߞߊ߲</language>
			<language type="yi">ߦߘߌߛߌߞߊ߲</language>
			<language type="yo">ߙߦߏߓߊߞߊ߲</language>
			<language type="yue">ߞߊ߲ߕߏߣߊߞߊ߲</language>
			<language type="yue" alt="menu">ߞߊ߲ߕߏߣߊ ߛߣߌߥߊߞߊ߲</language>
			<language type="zgh">ߡߊ߬ߙߐߞߎ߬ ߢߊߓߘߍߡߊ</language>
			<language type="zh">ߛߣߌߥߊߞߊ߲</language>
			<language type="zh" alt="menu">ߛߣߌߥߊ ߡߊ߲ߘߊߙߍ߲ߞߊ߲</language>
			<language type="zh_Hans">ߛߣߌߥߊߞߊ߲ ߘߐߞߣߍߣߍ߲</language>
			<language type="zh_Hans" alt="long">ߡߊ߲ߘߊߙߍ߲ ߘߐߞߣߍߣߍ߲</language>
			<language type="zh_Hant">ߛߣߌߥߊߞߊ߲ ߦߋ߲ߢߐ߲߯ߠߊ</language>
			<language type="zh_Hant" alt="long">ߡߊ߲ߘߊߙߍ߲ߞߊ߲ ߢߋ߲ߢߐ߲߯ߠߊ</language>
			<language type="zu">ߖ߭ߟߎߞߊ߲</language>
			<language type="zxx">ߞߊ߲߫ ߘߐߞߏߟߏ߲</language>
		</languages>
		<scripts>
			<script type="Adlm">ߊߘߑߟߊߡ</script>
			<script type="Aghb">ߊߜ߭ߑߓߊߣߌ</script>
			<script type="Ahom">ߊߤߏ߲</script>
			<script type="Arab">ߊߙߊߓߎ</script>
			<script type="Aran">ߣߊߛߑߕߊߟߌߞ</script>
			<script type="Armi">ߝߊ߰ߡߊ߬ߟߊ-ߊߙߊߡߋ</script>
			<script type="Armn">ߊߙߌߡߋߣߌ</script>
			<script type="Avst">ߊߝ߭ߋߛߑߕߌ</script>
			<script type="Bali">ߓߊߟߌߣߍ</script>
			<script type="Bamu">ߓߊߡߎ߲</script>
			<script type="Bass">ߓߊ߯ߛߊ</script>
			<script type="Batk">ߓߕߊߞ</script>
			<script type="Beng">ߓߍ߲ߜ߭ߊߟߌ</script>
			<script type="Bhks">ߓߊߦߌߞߑߛߎߞߌ</script>
			<script type="Bopo">ߔߓߏߡߝߏ</script>
			<script type="Brah">ߓߑߙߊߤߡߌ</script>
			<script type="Brai">ߓߑߙߊߦߌ</script>
			<script type="Bugi">ߓߎߜ߭ߌ</script>
			<script type="Buhd">ߓߎߤߌߘ</script>
			<script type="Cakm">ߗߍߞߑߡߊ</script>
			<script type="Cans">ߞߣߊߘߊ߫ ߘߎ߰ߙߋ߲߬ ߛߓߍ߬ߛߎ߲߬ ߞߝߊ ߟߊߘߍ߬ߣߍ߲</script>
			<script type="Cari">ߞߊ߯ߙߌ</script>
			<script type="Cham">ߛߊ߲</script>
			<script type="Cher">ߛߋߙߐߞ</script>
			<script type="Chrs">ߞߏߙߊߦߌߛߑߡߌ</script>
			<script type="Copt">ߞߐߔߑߕ</script>
			<script type="Cpmn">ߛߌߔߙߏ-ߡߌߣߏߞߊ</script>
			<script type="Cprt">ߛߔߙߌߐߕ ߜߋ߲߬ߞߝߊ</script>
			<script type="Cyrl">ߛߙߌߟߌߞ</script>
			<script type="Deva">ߘߋߝ߭ߣߊߜ߭ߊߙߌ߫</script>
			<script type="Diak">ߊߞߎ߯ߙߎ</script>
			<script type="Dogr">ߘߏߜ߭ߑߙߌ</script>
			<script type="Dsrt">ߘߖ߭ߋߙߋ</script>
			<script type="Dupl">ߛߑߕߋߣߏߜ߭ߙߊߝߌ ߘߎߔߑߟߏߦߋ</script>
			<script type="Egyp">ߋߖ߭ߌߔߑߕ ߤߌߙߏߜ߭ߟߌߝߌ</script>
			<script type="Elba">ߍߟߑߓߊߛߊ߲</script>
			<script type="Elym">ߋߟߌߡߊߦߌߞ</script>
			<script type="Ethi">ߋߗߏߔߌߞ</script>
			<script type="Geor">ߖ߭ߐߙߑߖ߭ߌߞߊ</script>
			<script type="Glag">ߜ߭ߑߟߊߜ߭ߏߟߌߕߌߞ</script>
			<script type="Gong">ߜ߭ߏ߲ߖߌ߫ ߜ߭ߎ߲ߖߋߟߊ ߘߐ߫</script>
			<script type="Gonm">ߡߛߊߙߊ߲߫-ߜ߭ߏ߲ߘߌ</script>
			<script type="Goth">ߜ߭ߏߕߌߞ</script>
			<script type="Gran">ߜ߭ߑߙߊ߲ߗߊ</script>
			<script type="Grek">ߜ߭ߙߍ߬ߞߌ</script>
			<script type="Gujr">ߜ߭ߎߖߙߊߕߌ</script>
			<script type="Guru">ߜ߭ߎߙߑߡߎߞߌ</script>
			<script type="Hanb">ߤߊ߲߫ ߓߔߏߡߝߏ ߘߐ߫</script>
			<script type="Hang">ߤߊ߲ߜ߭ߎ</script>
			<script type="Hani">ߛߌߣߏߜ߭ߙߊߡ</script>
			<script type="Hano">ߤߊߣߎߣߏ</script>
			<script type="Hans">ߘߐߞߣߍߣߍ߲</script>
			<script type="Hans" alt="stand-alone">ߛߌߣߏߜ߭ߙߊߡ ߘߐߞߣߍߣߍ߲</script>
			<script type="Hant">ߦߋߢߐ߲߯ߠߊ</script>
			<script type="Hant" alt="stand-alone">ߛߌߣߏߜ߭ߙߊߡ ߦߋߢߐ߲߯ߠߊ</script>
			<script type="Hatr">ߤߊߕߙߋߣߌ</script>
			<script type="Hebr">ߋߓߙߋ</script>
			<script type="Hira">ߤߌߙߊߜ߭ߣߊ</script>
			<script type="Hluw">ߤߕߌ-ߤߙߏߜ߭ߟߌߝߌ</script>
			<script type="Hmng">ߔߤߊߥ ߡߐ߲ߜ߭</script>
			<script type="Hmnp">ߢߊߞߋ߲ߜ߭ ߔߎߛߑߡߐ߲ߜ߭</script>
			<script type="Hrkt">ߞߊߕߊ߲ߞߣߊ</script>
			<script type="Hung">ߤߐ߲ߜ߭ߙߌ߫ ߞߘߐ߬ߡߊ߲</script>
			<script type="Ital">ߌߕߊߟߌߞ ߞߘߐ߬ߡߊ߲</script>
			<script type="Jamo">ߖߡߏ</script>
			<script type="Java">ߖ߭ߝ߭ߊߣߍߛ</script>
			<script type="Jpan">ߣߌߔߐ߲߫</script>
			<script type="Kali">ߞߦߊߟߌ߫</script>
			<script type="Kana">ߞߕߊߞߣߊ</script>
			<script type="Khar">ߞߊߙߏߗߌ߮</script>
			<script type="Khmr">ߞߑߡߍߙ</script>
			<script type="Khoj">ߞߏߖߞߌ</script>
			<script type="Kits">ߞߌߕߊ߲߫ ߛߓߍߟߌߣߍ߲</script>
			<script type="Knda">ߞߌߡߍߙ</script>
			<script type="Kore">ߞߏߙߋ߫</script>
			<script type="Kthi">ߞߊߦߌߗߌ߮</script>
			<script type="Lana">ߟߣߊ</script>
			<script type="Laoo">ߟߊߏ</script>
			<script type="Latn">ߟߊ߬ߕߍ߲</script>
			<script type="Lepc">ߟߋߔߑߛߊ</script>
			<script type="Limb">ߟߌ߲ߓߎ</script>
			<script type="Lina">ߟߌߣߍ߯ߙ ߊ</script>
			<script type="Linb">ߟߌߣߍ߯ߙ ߓ</script>
			<script type="Lisu">ߟߌߛߎ</script>
			<script type="Lyci">ߟߛߌ</script>
			<script type="Lydi">ߟߘߌ</script>
			<script type="Mahj">ߡߤߊߖߊߣߌ</script>
			<script type="Maka">ߡߞߊߛߊ߯ߙ</script>
			<script type="Mand">ߡߊ߲߬ߘߋ߲߬ߞߊ ߡߋߛߔߏߕߊߡߌ߫</script>
			<script type="Mani">ߡߊߣߌߛߋ</script>
			<script type="Marc">ߡߊߙߑߛߋ</script>
			<script type="Medf">ߡߋߘߑߝߘߌߙߌ߲</script>
			<script type="Mend">ߡߍ߲߬ߘߋ</script>
			<script type="Merc">ߡߋߞߙߏߕߌߞ ߞߎ߳ߙߑߛߌߝ</script>
			<script type="Mero">ߡߋߙߏߦߕߌߞ</script>
			<script type="Mlym">ߡߟߊߦߊߟߊ߲</script>
			<script type="Modi">ߡߏߘߌ</script>
			<script type="Mong">ߡߐ߲ߜ߭ߐߟ</script>
			<script type="Mroo">ߡߑߙߏ</script>
			<script type="Mtei">ߡߋߦߌߕߋ ߡߊߦߌߞ</script>
			<script type="Mult">ߡߎߟߑߕߊߣߌ</script>
			<script type="Mymr">ߓߙߌߡߊ߲</script>
			<script type="Nand">ߣߊ߲ߘߌߣߜ߭ߊߙߌ</script>
			<script type="Narb">ߕߟߋ߬ߓߐ-ߊߙߊߓߎ</script>
			<script type="Nbat">ߣߓߊߕߋ</script>
			<script type="Newa">ߣߋߥߊ</script>
			<script type="Nkoo">ߒߞߏ</script>
			<script type="Nshu">ߣߎ߳ߛߎ</script>
			<script type="Ogam">ߏߜ߭ߊ߲</script>
			<script type="Olck">ߏߟߑߗߞߌ</script>
			<script type="Orkh">ߐߙߑߞߐ߲</script>
			<script type="Orya">ߏߖߊ</script>
			<script type="Osge">ߏߛߊߖ߭</script>
			<script type="Osma">ߎߛߑߡߊߣߌ</script>
			<script type="Ougr">ߎߜ߭ߎߙ ߞߘߐ߬ߡߊ߲</script>
			<script type="Palm">ߔߊߟߑߡߙߋߣߌ</script>
			<script type="Pauc">ߔߊߎ-ߛߌ߲ߤߊߥߎ</script>
			<script type="Perm">ߡߙߋߡߌ߫ ߞߘߐ߬ߡߊ߲</script>
			<script type="Phag">ߝߊߜ߭-ߔߊ</script>
			<script type="Phli">ߝߋ߲ߟߋߥߌ߫ ߛߓߍߟߌ ߟߎ߬</script>
			<script type="Phlp">ߛߏߕߌߦߋ߫ ߝߋ߲ߟߋߝ߭ߌ</script>
			<script type="Phnx">ߝߋߣߌߛߌ</script>
			<script type="Plrd">ߔߏߟߊߙ ߞߊ߲ߡߊߛߙߋߡߊ</script>
			<script type="Prti">ߔߊߙߑߕ ߛߓߍߟߌ</script>
			<script type="Qaag">ߖ߭ߊߎߜ߭ߌ</script>
			<script type="Rjng">ߙߋߖ߭ߊ߲ߜ߭</script>
			<script type="Rohg">ߤߊߣߝߌ</script>
			<script type="Runr">ߙߎߣߌߞ</script>
			<script type="Samr">ߛߡߊߙߌߕߍ߲</script>
			<script type="Sarb">ߥߙߏ߬ߘߎ߮ ߊߙߊߓߎ߫ ߞߘߐ߬ߡߊ߲</script>
			<script type="Saur">ߛߏߙߊߗߌߙߊ</script>
			<script type="Sgnw">ߞߐߙߍߦߊ߫-ߛߓߍߟߌ ߟߎ߬</script>
			<script type="Shaw">ߛߊߝ߭ߌ</script>
			<script type="Shrd">ߛߙߊߘߊ</script>
			<script type="Sidd">ߛߌߘߊߡ</script>
			<script type="Sind">ߛߌ߲ߘߌ</script>
			<script type="Sinh">ߛߌ߲ߜ߭ߟߊ</script>
			<script type="Sogd">ߛߏߜ߭ߑߘߌ</script>
			<script type="Sogo">ߛߏߜ߭ߑߘߌ ߞߘߐ߬ߡߊ߲</script>
			<script type="Sora">ߛߏߙߊ ߛߎ߲ߔߍ߲ߜ߭</script>
			<script type="Soyo">ߛߏߦߏ߲ߓߏ</script>
			<script type="Sund">ߛߎ߲ߘߣߊ</script>
			<script type="Sylo">ߛߌߟߏߕߌ ߣߊߜ߭ߑߙߌ</script>
			<script type="Syrc">ߛߙߌߦߊߞ</script>
			<script type="Tagb">ߕߜߊߣߎߥߊ</script>
			<script type="Takr">ߕߊߞߙߌ</script>
			<script type="Tale">ߕߊߦߌ-ߟߋ߫</script>
			<script type="Talu">ߕߊߦߌ-ߟߎ߫ ߞߎߘߊ߫</script>
			<script type="Taml">ߕߊߡߎߟ</script>
			<script type="Tang">ߕߊ߲ߜ߭ߎߕ</script>
			<script type="Tavt">ߕߊߦߌ-ߝ߭ߌߋ߫</script>
			<script type="Telu">ߕߟߋߜ߭ߎ</script>
			<script type="Tfng">ߕߝߌߣߊߜ߭</script>
			<script type="Tglg">ߕߜ߭ߊߟ</script>
			<script type="Thaa">ߕߡߊ</script>
			<script type="Thai">ߕߊߦߌ</script>
			<script type="Tibt">ߕߓߌߕߋߕߍ߲</script>
			<script type="Tirh">ߕߌߙߎߕߊ</script>
			<script type="Tnsa">ߕߊ߲ߜߑߛߊ߫</script>
			<script type="Toto">ߕߏߕߏ߫</script>
			<script type="Ugar">ߎߜ߭ߊߙߕߌߞ</script>
			<script type="Vaii">ߒߝ߭ߊߦߌ</script>
			<script type="Vith">ߝ߭ߌߕߑߞߎߜ߭ߌ߫</script>
			<script type="Wara">ߥߊߙߊ߲ߜ߭ ߛߕߌ</script>
			<script type="Wcho">ߥߊ߲ߗߏ</script>
			<script type="Xpeo">ߝߊ߯ߙߛߌ߫ ߞߘߐߡߊ߲</script>
			<script type="Xsux">ߛߎߡߋߙߏ-ߊߞߊߘߌ</script>
			<script type="Yezi">ߦߋߖ߭ߘߌ</script>
			<script type="Yiii">ߦߌ</script>
			<script type="Zanb">ߖ߭ߣߊߓߊߖ߭ߊ߯ߙ ߝߘߎ߬ߓߍ߲</script>
			<script type="Zinh">ߤߋߙߌߕߋ</script>
			<script type="Zmth">ߘߡߊ߬ߟߐ߲ ߛߙߍߛߙߍߦߊߟߌ</script>
			<script type="Zsye">ߋߡߏߖߌ߬</script>
			<script type="Zsym">ߕߐ߰ߡߊ߬ߛߙߋ</script>
			<script type="Zxxx">ߛߓߍߓߊߟߌ</script>
			<script type="Zyyy">ߞߏߡߎ߲</script>
			<script type="Zzzz">ߛߓߍߟߌ߫ ߡߊߟߐ߲ߓߊߟߌ</script>
		</scripts>
		<territories>
			<territory type="001">ߞߌߢߍ߲߫</territory>
			<territory type="002">ߝߘߊ߬ߝߌ߲߬ߠߊ߫</territory>
			<territory type="003">ߊߡߋߙߌߞߌ߬ ߞߐ߬ߘߎ߮</territory>
			<territory type="005">ߊߡߋߙߌߞߌ߬ ߥߙߏ߬ߘߎ߮</territory>
			<territory type="009">ߟߌ߲ߓߊ߲ߘߎ߯</territory>
			<territory type="011">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߟߋ߬ߓߋ</territory>
			<territory type="013">ߊߡߋߙߌߞߌ߬ ߕߊ߲ߓߊ߲</territory>
			<territory type="014">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߟߋ߬ߓߐ</territory>
			<territory type="015">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߞߐ߬ߘߎ߮</territory>
			<territory type="017">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߊ߲ߓߊ߲</territory>
			<territory type="018">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߥߙߏ߬ߘߎ߮</territory>
			<territory type="019">ߊߡߋߙߌߞߌ߬</territory>
			<territory type="021">ߞߐ߰ߘߎ߮ ߊߡߋߙߌߞߌ߬</territory>
			<territory type="029">ߞߙߊߦߌߓ</territory>
			<territory type="030">ߊߖ߭ߌ߫ ߕߟߋ߬ߓߐ</territory>
			<territory type="034">ߊߖ߭ߌ߫ ߥߙߏ߬ߘߎ߮</territory>
			<territory type="035">ߊߖ߭ߌ߫ ߥߙߏ߬ߘߎ߮-ߕߟߋ߬ߓߐ</territory>
			<territory type="039">ߋߙߐߔߎ߬ ߥߙߏ߬ߘߎ߮</territory>
			<territory type="053">ߐߛߑߕߙߊߟߊߖ߭ߌ߫</territory>
			<territory type="054">ߡߋߟߊߣߋߖ߭ߌ߫</territory>
			<territory type="057">ߡߌߞߙߏߣߋߖ߭ߌ߫ ߕߌ߲߬ߞߎߘߎ߲</territory>
			<territory type="061">ߔߏߟߣߋߖ߭ߌ߫</territory>
			<territory type="142">ߊߖ߭ߌ߫</territory>
			<territory type="143">ߊߖ߭ߌ߫ ߕߊ߲ߓߊ߲</territory>
			<territory type="145">ߊߖ߭ߌ߫ ߕߟߋ߬ߓߋ</territory>
			<territory type="150">ߋߙߐߔߎ߬</territory>
			<territory type="151">ߋߙߐߔߎ߬ ߕߟߋ߬ߓߐ</territory>
			<territory type="154">ߋߙߐߔߎ߬ ߞߐ߬ߘߎ߮</territory>
			<territory type="155">ߋߙߐߔߎ߬ ߕߟߋ߬ߓߋ</territory>
			<territory type="202">ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߞߌ߬ߢߍ߬ߞߏ߲ߞߏ߫ ߘߎ߰ߟߊ߬-ߖߡߊߣߊ</territory>
			<territory type="419">ߊߡߋߙߞߌ߬ ߟߊ߬ߕߍ߬ߡߊ߬ ߦߙߐ</territory>
			<territory type="AC">ߊߛߊ߲ߛߌߦߐ߲߫ ߕߌ߲</territory>
			<territory type="AD">ߊ߲ߘߐߙ</territory>
			<territory type="AE">ߋߡߌߙߊߕ ߊߙߊߓߎ߫ ߘߍ߬ߣߍ߲</territory>
			<territory type="AF">ߊߝߎߜ߭ߊߣߌߛߑߕߊ߲߫</territory>
			<territory type="AG">ߊ߲ߕߌߞߎߥߊ߫ ߣߌ߫ ߓߊߙߑߓߎߘߊ߫</territory>
			<territory type="AI">ߊ߲ߞߎ߳ߟߊ߫</territory>
			<territory type="AL">ߊߟߑߓߊߣߌ߫</territory>
			<territory type="AM">ߊߙߑߡߋߣߌ߫</territory>
			<territory type="AO">ߊ߲ߜߏߟߊ߫</territory>
			<territory type="AQ">ߊ߲ߕߊߙߑߛߕߌߞ</territory>
			<territory type="AR">ߊߙߑߖ߭ߊ߲ߕߌߣ</territory>
			<territory type="AS">ߛߊߡߏߥߊ߫ ߊߡߋߙߞߌߞߊ</territory>
			<territory type="AT">ߏߕߑߙߌߛ</territory>
			<territory type="AU">ߐߛߑߕߙߊߟߌ߫</territory>
			<territory type="AW">ߊߙߎߓߊ߫</territory>
			<territory type="AX">ߊߟߊ߲ߘ ߕߌ߲</territory>
			<territory type="AZ">ߊߖߊߙߑߓߊߦߌߖߊ߲</territory>
			<territory type="BA">ߓߐߛߑߣߌ߫-ߍߙߑߖ߭ߋߜ߭ߏߝ߭ߌߣ</territory>
			<territory type="BB">ߓߊߙߑߓߊߘ</territory>
			<territory type="BD">ߓߊ߲ߜ߭ߑߟߊߘߍߛ</territory>
			<territory type="BE">ߓߍߟߑߖ߭ߌߞ</territory>
			<territory type="BF">ߓߙߎߞߌߣߊ߫ ߝߊ߬ߛߏ߫</territory>
			<territory type="BG">ߓߌߟߑߜ߭ߊ߯ߙߌ߫</territory>
			<territory type="BH">ߓߤߊ߬ߙߊߦߌ߬ߣ</territory>
			<territory type="BI">ߓߎߙߎ߲ߘߌ߫</territory>
			<territory type="BJ">ߓߋߣߍ߲߫</territory>
			<territory type="BL">ߛߍ߲ߕ-ߓߌߙߑߕߟߋߡߌ߫</territory>
			<territory type="BM">ߓߍߙߑߓߎߘ</territory>
			<territory type="BN">ߓߙߎߣߋ߫</territory>
			<territory type="BO">ߓߏߟߝ߭ߌ߫</territory>
			<territory type="BQ">ߤߏߟߊ߲ߘ ߞߊߙߌߓߋ߫</territory>
			<territory type="BR">ߓߙߋߖ߭ߌߟ</territory>
			<territory type="BS">ߓߤߊߡߊߛ</territory>
			<territory type="BT">ߓߎߕߊ߲߫</territory>
			<territory type="BV">ߓߎߝ߭ߋ߫ ߕߌ߲</territory>
			<territory type="BW">ߓߐߛߎߥߣߊ߫</territory>
			<territory type="BY">ߓߌߟߏߙߌߛ</territory>
			<territory type="BZ">ߓߋߟߌߖ߭</territory>
			<territory type="CA">ߞߣߊߘߊ߫</territory>
			<territory type="CC">ߞߏߞߏ߫ ߕߌ߲</territory>
			<territory type="CD">ߞߏ߲߬ߜ߭ߏ߫-ߞߌ߲ߛߊߛߊ߫</territory>
			<territory type="CD" alt="variant">ߞߏ߲߬ߜ߭ߏ߫ ߓߍ߯ߦߊ߫ ߞߊ߲ߓߍ߲</territory>
			<territory type="CF">ߕߊ߲ߓߊ߲-ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߞߊ߲ߓߍ߲</territory>
			<territory type="CG">ߞߏ߲߬ߜ߭ߏ߫-ߓߙߊߖ߭ߊ߫</territory>
			<territory type="CG" alt="variant">ߞߏ߲߬ߜ߭ߏ߫ ߞߊ߲ߓߍ߫</territory>
			<territory type="CH">ߛߎߥߌߛ</territory>
			<territory type="CI">ߜߋ߲-ߞߐ߰ߖߌ߬ߘߊ</territory>
			<territory type="CI" alt="variant">ߜߋ߲-ߞߐ߰ߖߌ߬ߘߊ ߞߊ߲ߓߍ߲</territory>
			<territory type="CK">ߞߎߞ ߕߌ߲</territory>
			<territory type="CL">ߛ߭ߟߌ߫</territory>
			<territory type="CM">ߞߊߡߋߙߎ߲</territory>
			<territory type="CN">ߛߌߣ</territory>
			<territory type="CO">ߞߏߟߐ߲ߓߌ߫</territory>
			<territory type="CP">ߞߟߌߔߍߙߑߕߐ߲߫ ߕߌ߲</territory>
			<territory type="CR">ߞߐߛߑߕߊ߫ ߙߌߞߊ߫</territory>
			<territory type="CU">ߞߎ߳ߓߊ߫</territory>
			<territory type="CV">ߜߙߋߞߎ߲߫-ߝߙߌߛߌ߫</territory>
			<territory type="CW">ߞߎߙߛߊߏ߫</territory>
			<territory type="CX">ߞߙߌߛߑߕߌߡߊ߫ ߕߌ߲</territory>
			<territory type="CY">ߛߌߔߑߙߎ߫</territory>
			<territory type="CZ">ߗߍߞ</territory>
			<territory type="CZ" alt="variant">ߗߍߞ ߞߊ߲ߓߍ߲</territory>
			<territory type="DE">ߊߟߑߡߊ߲ߘߎ߯</territory>
			<territory type="DG">ߖߋߜ߭ߏ߫-ߜ߭ߊߙߑߛߌߦߊ߫</territory>
			<territory type="DJ">ߖߌߓߎߕߌ߫</territory>
			<territory type="DK">ߘߊߣߌߡߊߙߑߞ</territory>
			<territory type="DM">ߘߏߡߣߌߞ</territory>
			<territory type="DO">ߘߏߡߣߌߞ ߞߊ߲ߓߍ߲</territory>
			<territory type="DZ">ߊߟߑߖ߭ߋߙߌ߫</territory>
			<territory type="EA">ߛߋߎߕߊ߫ ߣߌ߫ ߡߋߟߌߣߊ߫</territory>
			<territory type="EC">ߕߍߡߊߓߊ߲߮</territory>
			<territory type="EE">ߋߛߑߕߏߣߌ߫</territory>
			<territory type="EG">ߋߖ߭ߌߔߑߕ</territory>
			<territory type="EH">ߞߌ߲߬ߢߍ߬ߞߏ߲ߞߏ߫ ߕߟߋ߬ߓߋ</territory>
			<territory type="ER">ߋߙߕߌߙߋ߫</territory>
			<territory type="ES">ߊߛߌߔߊ߲߫</territory>
			<territory type="ET">ߋߗߏߔߌ߫</territory>
			<territory type="EU">ߋߙߐߔߎ߬ ߘߍ߭</territory>
			<territory type="EZ">ߋߙߐߔߎ߬ ߞߣߍ</territory>
			<territory type="FI">ߝߍ߲ߟߊ߲ߘ</territory>
			<territory type="FJ">ߝߖߌ߫</territory>
			<territory type="FK">ߡߊߟߎ߲ߌ߲߫ ߕߌ߲</territory>
			<territory type="FK" alt="variant">ߡߊߟߎ߲ߌ߲߫ ߕߌ߲ ( ߝߊߟߑߞߑߟߊ߲ ߕߌ߲ )</territory>
			<territory type="FM">ߡߌߞߙߏߣߋߖ߭ߌ߫</territory>
			<territory type="FO">ߝߋߙߏߦߋ߫ ߕߌ߲</territory>
			<territory type="FR">ߝߊ߬ߙߊ߲߬ߛߌ߫</territory>
			<territory type="GA">ߜ߭ߊߓߐ߲߫</territory>
			<territory type="GB">ߡߊ߲߬ߛߊ߬ߟߊ߫ ߟߊߘߍ߬ߣߍ߲</territory>
			<territory type="GB" alt="short">ߡ.ߟ.</territory>
			<territory type="GD">ߜ߭ߙߋߣߊߘ</territory>
			<territory type="GE">ߖ߭ߋߐߙߑߖ߭ߌ߫</territory>
			<territory type="GF">ߝߊ߲߬ߙߊ߲߬ߛߌ߫ ߜ߭ߎ߳ߦߊߣ</territory>
			<territory type="GG">ߜ߭ߋߙߑߣߋߖ߭ߌ߫</territory>
			<territory type="GH">ߜ߭ߊ߯ߣߊ߫</territory>
			<territory type="GI">ߜ߭ߌߓߙߊߟߑߕߊߙ</territory>
			<territory type="GL">ߜ߭ߎߙߎ߲ߟߊ߲ߘ</territory>
			<territory type="GM">ߜ߭ߊ߲ߓߌ߫</territory>
			<territory type="GN">ߖߌ߬ߣߍ߫</territory>
			<territory type="GP">ߜ߭ߎߥߊߘߋߟߎߔ</territory>
			<territory type="GQ">ߕߍߡߊߓߊ߲߮-ߖߌ߬ߣߍ߫</territory>
			<territory type="GR">ߜ߭ߙߍ߬ߞߌ߬</territory>
			<territory type="GS">ߖ߭ߐߙߑߖ߭ߌ߫ ߥߙߏ߬ߘߎ߮ ߣߌ߫ ߛߊ߲ߘߎߥߌߛ ߕߌ߲</territory>
			<territory type="GT">ߜ߭ߎߥߊߕߋߡߟߊ߫</territory>
			<territory type="GU">ߜ߭ߎߥߊߡ</territory>
			<territory type="GW">ߖߌ߬ߣߍ߫ ߓߌߛߊߥߏ߫</territory>
			<territory type="GY">ߜ߭ߎߦߊߣ</territory>
			<territory type="HK">ߛߌߣ ߕߌ߲߬ߞߎߘߎ߲߫ ߡߊߡߙߊ߬ߣߍ߲ ߤߐ߲ߞߐ߲߫</territory>
			<territory type="HK" alt="short">ߤߐ߲ߞߐ߲߫</territory>
			<territory type="HM">ߡߊߞߑߘߏߣߊߟߑߘ ߕߌ߲</territory>
			<territory type="HN">ߤߎ߲ߘߎߙߊ߫</territory>
			<territory type="HR">ߞߙߏߥߊߛߌ߫</territory>
			<territory type="HT">ߤߊߦߕߌ߫</territory>
			<territory type="HU">ߤߐ߲ߜ߭ߙߌ߫</territory>
			<territory type="IC">ߞߣߊߙߌ߫ ߕߌ߲</territory>
			<territory type="ID">ߍ߲ߘߣߏߖ߭ߌ߫</territory>
			<territory type="IE">ߌߙߑߟߊ߲ߘ</territory>
			<territory type="IL">ߌߛߑߙߊߍߟ</territory>
			<territory type="IM">ߡߊ߲߯ ߕߌ߲</territory>
			<territory type="IN">ߌߘߎ߬</territory>
			<territory type="IO">ߓߙߌߕߊ߲ߓߊ߫ ߟߊ߫ ߌ߲ߘߎ߫ ߟߌ߲ߓߊ߲ ߞߣߍ</territory>
			<territory type="IQ">ߌߙߊߞߌ߬</territory>
			<territory type="IR">ߌߙߊ߲߫</territory>
			<territory type="IS">ߌߛߑߟߊߘ</territory>
			<territory type="IT">ߌߕߊߟߌ߫</territory>
			<territory type="JE">ߖߋߙߑߖ߭ߌ߫</territory>
			<territory type="JM">ߖ߭ߡߊߦߌߞ</territory>
			<territory type="JO">ߖߐߙߑߘߊߣߌ߫</territory>
			<territory type="JP">ߖ߭ߊߔߐ߲߫</territory>
			<territory type="KE">ߞߋߣߌߦߊ߫</territory>
			<territory type="KG">ߞߌߙߑߜ߭ߌߛߑߕߊ߲߫</territory>
			<territory type="KH">ߞߊ߲ߓߐߘߑߖ</territory>
			<territory type="KI">ߞߙߌߓߊߕߌ߫</territory>
			<territory type="KM">ߞߡߐߙ</territory>
			<territory type="KN">ߛߍ߲ߕ-ߞߙߌߛߑߕߐߝ ߣߌ߫ ߢߝ߭ߋ߫</territory>
			<territory type="KP">ߞߐ߬ߘߎ߮ ߞߏ߯ߙߋ߫</territory>
			<territory type="KR">ߕߟߋ߬ߓߋ ߞߏ߯ߙߋ߫</territory>
			<territory type="KW">ߞߎ߬ߥߊ߬ߕ</territory>
			<territory type="KY">ߓߊ߲߬ߓߊ߬-ߕߌ߲</territory>
			<territory type="KZ">ߞߖ߭ߊߞߌߛߑߕߊ߲߫</territory>
			<territory type="LA">ߟߊߐߛ</territory>
			<territory type="LB">ߟߌߓߊ߲߫</territory>
			<territory type="LC">ߛߍ߲ߕ-ߟߎ߳ߛߌ߫</territory>
			<territory type="LI">ߟߎߛߑߕߊ߲ߛߑߕߍ߲߫</territory>
			<territory type="LK">ߛߙߌߟߊ߲ߞߊ߫</territory>
			<territory type="LR">ߟߌߓߋߙߌߦߊ߫</territory>
			<territory type="LS">ߟߋߛߕߏ߫</territory>
			<territory type="LT">ߟߎߕߎ߳ߦߊߣߌ߫</territory>
			<territory type="LU">ߟߎߜ߭ߑߛߊ߲ߓߎ߯ߙ</territory>
			<territory type="LV">ߟߋߕߏߣߌ߫</territory>
			<territory type="LY">ߟߓߌ߫</territory>
			<territory type="MA">ߡߊ߬ߙߐߞߎ߬</territory>
			<territory type="MC">ߡߏߣߊߞߏ߫</territory>
			<territory type="MD">ߡߐߟߑߘߊߝ߭ߌ߫</territory>
			<territory type="ME">ߡߐ߲ߕߣߋߜ߭ߙߏ߫</territory>
			<territory type="MF">ߛߍ߲ߕ-ߡߊߙߑߕߍ߲߫</territory>
			<territory type="MG">ߡߘߊߜ߭ߛߑߞߊ߯ߙ</territory>
			<territory type="MH">ߡߊߙߑߛߊߟ ߕߌ߲</territory>
			<territory type="MK">ߞߐ߬ߘߎ߮ ߡߊߛߋߘߏߣߌ߫</territory>
			<territory type="ML">ߡߊ߬ߟߌ߬</territory>
			<territory type="MM">ߡߌߦߊߡߊ߯ߙ ( ߓߙߌߡߊߣߌ߫ )</territory>
			<territory type="MN">ߡߐ߲ߜ߭ߐߟߌ߫</territory>
			<territory type="MO">ߛߌߣ ߕߌ߲߬ߞߎߘߎ߲߫ ߡߊߡߙߊ߬ߣߍ߲ ߡߞߊߥߏ߫</territory>
			<territory type="MO" alt="short">ߡߞߊߥߏ߫</territory>
			<territory type="MP">ߡߊߙߌߦߊߣ ߞߐ߬ߘߎ߮ ߕߌ߲</territory>
			<territory type="MQ">ߡߊߙߑߕߣߌߞ</territory>
			<territory type="MR">ߡߏߙߌߕߊߣߌ߫</territory>
			<territory type="MS">ߡߐ߲ߗߋߙߊ߫</territory>
			<territory type="MT">ߡߊߟߑߕ</territory>
			<territory type="MU">ߡߏߙߌߛ</territory>
			<territory type="MV">ߡߊߟߑߘߌߝ߭</territory>
			<territory type="MW">ߡߟߊߥߌ߫</territory>
			<territory type="MX">ߡߍߞߑߛߌߞ</territory>
			<territory type="MY">ߡߊߟߍߘߎ߯</territory>
			<territory type="MZ">ߡߏߖ߭ߊ߲ߓߌߞ</territory>
			<territory type="NA">ߣߊߡߌ߲ߓߌ߫</territory>
			<territory type="NC">ߞߊߟߋߘߏߣߌ߫-ߞߎߘߊ߫</territory>
			<territory type="NE">ߖߋ߬ߟߌ߬ߓߊߘߎ߯</territory>
			<territory type="NF">ߣߐߙߑߝߐߟߑߞ</territory>
			<territory type="NG">ߖߋ߬ߟߌ߬ߓߊ߬ߟߊ߫</territory>
			<territory type="NI">ߣߌߞߙߊߜ߭ߎߥߊ߫</territory>
			<territory type="NL">ߤߏߟߊ߲ߘ</territory>
			<territory type="NO">ߣߐߙߑߝ߭ߍߖ</territory>
			<territory type="NP">ߣߋߔߊߟ</territory>
			<territory type="NR">ߣߏ߯ߙߎ߫</territory>
			<territory type="NU">ߣߎ߳ߋ߫</territory>
			<territory type="NZ">ߖ߭ߋߟߊ߲ߘߌ߫-ߞߎߘߊ߫</territory>
			<territory type="OM">ߏߡߊ߲߫</territory>
			<territory type="PA">ߔߣߊߡߊ߫</territory>
			<territory type="PE">ߔߋߙߎ߫</territory>
			<territory type="PF">ߝߊ߬ߙߊ߲߬ߛߌ߫ ߔߏߟߌߣߋߖ߭ߌ߫</territory>
			<territory type="PG">ߡߊߡߎߥߊߖ߭ߌ߫ ߖߌ߬ߣߍ߬-ߞߎߘߊ߫</territory>
			<territory type="PH">ߝߟߌߔߌ߲ߣ</territory>
			<territory type="PK">ߔߊߞߌߛߑߕߊ߲߫</territory>
			<territory type="PL">ߔߏߟߐߢ</territory>
			<territory type="PM">ߛߍ߲ߕ-ߔߍ߯ߙ ߣߌ߫ ߡߌ߲ߞߋߟߐ߲߫</territory>
			<territory type="PN">ߔߌߕߑߞߍ߲ ߕߌ߲</territory>
			<territory type="PR">ߔߐߙߑߕߏ߫-ߙߌߞߏ߫</territory>
			<territory type="PS">ߔߊߟߍߛߑߕߌߣ ߞߣߍ</territory>
			<territory type="PS" alt="short">ߔߊߟߍߛߑߕߌߣ</territory>
			<territory type="PT">ߔߐߙߑߕߎߜ߭ߊߟ</territory>
			<territory type="PW">ߔߟߊߐߛ</territory>
			<territory type="PY">ߔߙߊߜ߭ߏߦߋ߫</territory>
			<territory type="QA">ߞߊߕߊ߯ߙ</territory>
			<territory type="QO">ߟߌ߲ߓߊ߲ߘߎ߯ ߕߌ߲߬ߞߎߘߎ߲ ߦߙߐ߫ ߡߊߕߊ߯ߣߍ߲</territory>
			<territory type="RE">ߟߊ߬ߘߍ</territory>
			<territory type="RO">ߙߎߡߊߣߌ߫</territory>
			<territory type="RS">ߛߍߙߑߓߌ߫</territory>
			<territory type="RU">ߌߙߌ߬ߛߌ߫</territory>
			<territory type="RW">ߙߎߥߊ߲ߘߊ߫</territory>
			<territory type="SA">ߛߎ߰ߘߎ߬ߟߊ߫-ߡߊ߲߬ߛߊ߬ߟߊ</territory>
			<territory type="SB">ߛߊߟߏߡߐ߲߫ ߕߌ߲</territory>
			<territory type="SC">ߛߋߦߌߛߍߟ</territory>
			<territory type="SD">ߛߎߘߊ߲߫</territory>
			<territory type="SE">ߛߎߥߍߘ</territory>
			<territory type="SG">ߛߌ߲ߜ߭ߊߔߎߙ</territory>
			<territory type="SH">ߛߍ߲ߕ-ߋߟߍߣ</territory>
			<territory type="SI">ߛߑߟߏߝ߭ߋߣߌ߫</territory>
			<territory type="SJ">ߛߊߟߑߓߊߙ ߣߌ߫ ߖ߭ߊ߲ ߡߊߦߍ߲߫</territory>
			<territory type="SK">ߛߑߟߏߝ߭ߊߞߌ߫</territory>
			<territory type="SL">ߛߙߊ߬ߟߏ߲߫</territory>
			<territory type="SM">ߛߍߕ-ߡߊߙߍ߲߫</territory>
			<territory type="SN">ߛߣߍ߬ߜߊ߯ߟߌ߫</territory>
			<territory type="SO">ߛߏߡߊߟߌ߫</territory>
			<territory type="SR">ߛߎߙߑߣߊߡ</territory>
			<territory type="SS">ߥߙߏ߬ߘߎ߮ ߛߎ߬ߘߊ߲߫</territory>
			<territory type="ST">ߛߊߥߕߏߡߋ߫ ߣߌ߫ ߔߑߙߍ߲ߛߌߔ</territory>
			<territory type="SV">ߛߊߟߑߝ߭ߊߘߐߙ</territory>
			<territory type="SX">ߛߍ߲ߕ-ߡߊߙߑߕߍ߲߫ ( ߤߏߟߊ߲ߘ ߝߊ߲߭ߝߍ߬ )</territory>
			<territory type="SY">ߛߙߌ߫</territory>
			<territory type="SZ">ߒߛߎߥߊߕߣߌ߫</territory>
			<territory type="SZ" alt="variant">ߛߑߥߊߖ߭ߌߟߊ߲ߘ</territory>
			<territory type="TA">ߞߎ߲ߓߊ߫ ߕߑߙߌߛߑߕߊ߫</territory>
			<territory type="TC">ߕߎߙߑߞߌ߫ ߣߌ߫ ߞߊߦߌߞ</territory>
			<territory type="TD">ߗߊߘ</territory>
			<territory type="TF">ߝߊ߬ߙߊ߲߬ߛߌ߫ ߘߎ߰ߞߟߏ ߓߊߙߌ ߘߐ߫</territory>
			<territory type="TG">ߕߜ߭ߏ߫</territory>
			<territory type="TH">ߕߊߦߌߘߎ߯</territory>
			<territory type="TJ">ߕߊߖߞߌߛߑߕߊ߲߫</territory>
			<territory type="TK">ߕߏߞߋߟߊߏ߫</territory>
			<territory type="TL">ߕߌߡߐߙ ߕߟߋ߬ߓߐ߬ߝߊ߲</territory>
			<territory type="TL" alt="variant">ߕߌߡߐߙ ߕߟߋ߬ߓߐ</territory>
			<territory type="TM">ߕߎߙߑߞߌߡߋߣߌߛߑߕߊ߲߫</territory>
			<territory type="TN">ߕߎߣߖ߭ߌ߫</territory>
			<territory type="TO">ߕߏ߲ߜ߭ߊ߫</territory>
			<territory type="TR">ߕߎߙߑߞߌ߫</territory>
			<territory type="TT">ߕߙߌߣߌߕߋ߫ ߣߌ߫ ߕߏߓߊߜ߭ߏ߫</territory>
			<territory type="TV">ߕߎߝ߭ߊߟߎ߫</territory>
			<territory type="TW">ߕߊߦߌߥߊ߲߫</territory>
			<territory type="TZ">ߕߊ߲ߖ߭ߊߣߌ߫</territory>
			<territory type="UA">ߎ߳ߞߑߙߍߣ</territory>
			<territory type="UG">ߎߜ߭ߊ߲ߘߊ߫</territory>
			<territory type="UM">ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲ ߘߌߣߍ߲߫ ߕߌ߲߫ ߡߊߕߊ߯ߣߍ߲</territory>
			<territory type="UN">ߡߊ߲߬ߕߏ߲߫ ߠߊߘߍ߬ߣߍ߲ ߛߌ߬ߝߏ߲߬ߧߊ߬ߟߌ</territory>
			<territory type="US">ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲</territory>
			<territory type="US" alt="short">ߞ.ߘ.</territory>
			<territory type="UY">ߎ߳ߙߑߜ߭ߋߦߌ߫</territory>
			<territory type="UZ">ߎߖ߭ߑߓߋߞߌߛߑߕߊ߲߫</territory>
			<territory type="VA">ߝ߭ߊߕߌߞߊ߲߫ ߞߊ߬ߝߏ</territory>
			<territory type="VC">ߛߍ߲ߕ-ߝ߭ߍߛߊ߲ ߜ߭ߙߋߣߊߘߌ߫</territory>
			<territory type="VE">ߝ߭ߣߋߖ߭ߎߦߋߟߊ߫</territory>
			<territory type="VG">ߓߙߌߕߊ߲ߓߊ߫ ߕߌ߲߫ ߞߊߓߊ߲</territory>
			<territory type="VI">ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲ ߕߌ߲߫ ߞߊߓߊ߲߫</territory>
			<territory type="VN">ߝ߭ߌߦߍߕߑߣߊߡ</territory>
			<territory type="VU">ߝ߭ߊߣߎߦߊߕߎ߫</territory>
			<territory type="WF">ߥߊߟߌߛߌ߫ ߣߌ߫ ߝߕߎߣߊ߫</territory>
			<territory type="WS">ߛߊߡߏߥߊ߫</territory>
			<territory type="XA">ߔߛߏߘߏ߫ ߊߞߑߛߊ߲</territory>
			<territory type="XB">ߔߛߔߘߏ߫-ߓߘߌ߫</territory>
			<territory type="XK">ߞߛߏߝ߭ߏ߫</territory>
			<territory type="YE">ߦߡߊߣߌ߲߫</territory>
			<territory type="YT">ߡߊߦߐߕ</territory>
			<territory type="ZA">ߥߙߏ߬ߘߎ߮ ߝߘߊ߬ߝߌ߲߬ߠߊ߫</territory>
			<territory type="ZM">ߖ߭ߊ߲ߓߌ߫</territory>
			<territory type="ZW">ߖ߭ߌ߲ߓߊߓߏߦߋ߫</territory>
			<territory type="ZZ">ߕߌ߲߬ߞߎߘߎ߲߫ ߕߊ߲߬ߠߊߕߍ߰ߓߊߟߌ</territory>
		</territories>
		<measurementSystemNames>
			<measurementSystemName type="metric">ߜߟߊ߬ߜߟߊ߬ߡߊ</measurementSystemName>
			<measurementSystemName type="UK">ߓߙߌߕߊ߲ߓߊ߫ ߡߊ߲߬ߛߊ߬ߟߊ (ߓ.ߡ.)</measurementSystemName>
			<measurementSystemName type="US">ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲ (ߞ.ߘ.)</measurementSystemName>
		</measurementSystemNames>
		<codePatterns>
			<codePattern type="language">ߞߊ߲: {0}</codePattern>
			<codePattern type="script">ߛߓߍߟߌ: {0}</codePattern>
			<codePattern type="territory">ߕߌ߲߬ߞߎߘߎ߲: {0}</codePattern>
		</codePatterns>
	</localeDisplayNames>
	<layout>
		<orientation>
			<characterOrder>right-to-left</characterOrder>
		</orientation>
	</layout>
	<characters>
		<exemplarCharacters>[߫ ߬ ߭ ߮ ߯ ߰ ߱ ߲ ߳ ߊ ߋ ߌ ߍ ߎ ߏ ߐ ߑ ߒ ߓ ߔ ߕ ߖ ߗ ߘ ߙ ߚ ߛ ߜ ߝ ߞ ߟ ߠ ߡ ߢ ߣ ߤ ߥ ߦ ߧ ߴ ߵ]</exemplarCharacters>
		<exemplarCharacters type="auxiliary" draft="contributed">[ߨ ߩ ߪ]</exemplarCharacters>
		<exemplarCharacters type="numbers" draft="contributed">[\- ‑ ، . % ‰ + ߀ ߁ ߂ ߃ ߄ ߅ ߆ ߇ ߈ ߉]</exemplarCharacters>
		<exemplarCharacters type="punctuation">[߸ ߹ ߷]</exemplarCharacters>
	</characters>
	<dates>
		<calendars>
			<calendar type="gregorian">
				<months>
					<monthContext type="format">
						<monthWidth type="abbreviated">
							<month type="1">ߓߌ߲ߠ</month>
							<month type="2">ߞߏ߲ߞ</month>
							<month type="3">ߕߙߊ</month>
							<month type="4">ߞߏ߲ߘ</month>
							<month type="5">ߘߓߊ߬ߕ</month>
							<month type="6">ߥߊ߬ߛ</month>
							<month type="7">ߞߊ߬ߙ</month>
							<month type="8">ߘߓߊ߬ߓ</month>
							<month type="9">ߕߎߟߊߝߌ߲</month>
							<month type="10">ߞߏ߲ߓ</month>
							<month type="11">ߣߍߣ</month>
							<month type="12">ߞߏߟ</month>
						</monthWidth>
						<monthWidth type="wide">
							<month type="1">ߓߌ߲ߠߊߥߎߟߋ߲</month>
							<month type="2">ߞߏ߲ߞߏߜߍ</month>
							<month type="3">ߕߙߊߓߊ</month>
							<month type="4">ߞߏ߲ߞߏߘߌ߬ߓߌ</month>
							<month type="5">ߘߓߊ߬ߕߊ</month>
							<month type="6">ߥߊ߬ߛߌ߬ߥߙߊ</month>
							<month type="7">ߞߊ߬ߙߌߝߐ߭</month>
							<month type="8">ߘߓߊ߬ߓߌߟߊ</month>
							<month type="9">ߕߎߟߊߝߌ߲</month>
							<month type="10">ߞߏ߲ߓߌߕߌ߮</month>
							<month type="11">ߣߍߣߍߓߊ</month>
							<month type="12">ߞߏߟߌ߲ߞߏߟߌ߲</month>
						</monthWidth>
					</monthContext>
					<monthContext type="stand-alone">
						<monthWidth type="narrow">
							<month type="1">ߓ</month>
							<month type="2">ߞ</month>
							<month type="3">ߕ</month>
							<month type="4">ߞ</month>
							<month type="5">ߘ</month>
							<month type="6">ߥ</month>
							<month type="7">ߞ</month>
							<month type="8">ߘ</month>
							<month type="9">ߕ</month>
							<month type="10">ߞ</month>
							<month type="11">ߣ</month>
							<month type="12">ߞ</month>
						</monthWidth>
					</monthContext>
				</months>
				<days>
					<dayContext type="format">
						<dayWidth type="abbreviated">
							<day type="sun">ߞߊ߯ߙ</day>
							<day type="mon">ߞߐ߬ߓ</day>
							<day type="tue">ߞߐ߬ߟߏ߲</day>
							<day type="wed">ߞߎߣ</day>
							<day type="thu">ߓߌߟ</day>
							<day type="fri">ߛߌ߬ߣ</day>
							<day type="sat">ߞߍ߲ߘ</day>
						</dayWidth>
						<dayWidth type="short">
							<day type="sun">ߞߊ߯</day>
							<day type="mon">ߞߐ߬</day>
							<day type="tue">ߞߐ߬ߟߏ߲</day>
							<day type="wed">ߞߎ</day>
							<day type="thu">ߓߌ</day>
							<day type="fri">ߛߌ߬</day>
							<day type="sat">ߞߍ߲</day>
						</dayWidth>
						<dayWidth type="wide">
							<day type="sun">ߞߊ߯ߙߌߟߏ߲</day>
							<day type="mon">ߞߐ߬ߓߊ߬ߟߏ߲</day>
							<day type="tue">ߞߐ߬ߟߏ߲</day>
							<day type="wed">ߞߎߣߎ߲ߟߏ߲</day>
							<day type="thu">ߓߌߟߏ߲</day>
							<day type="fri">ߛߌ߬ߣߌ߲߬ߟߏ߲</day>
							<day type="sat">ߞߍ߲ߘߍߟߏ߲</day>
						</dayWidth>
					</dayContext>
					<dayContext type="stand-alone">
						<dayWidth type="abbreviated">
							<day type="sun">ߞߊ߯ߙ</day>
							<day type="mon">ߞߐ߬ߓ</day>
							<day type="tue">ߞߐ߬ߟ</day>
							<day type="wed">ߞߎߣ</day>
							<day type="thu">ߓߌߟ</day>
							<day type="fri">ߛߌ߬ߣ</day>
							<day type="sat">ߞߍ߲ߘ</day>
						</dayWidth>
						<dayWidth type="narrow">
							<day type="sun">ߞ</day>
							<day type="mon">ߞ</day>
							<day type="tue">ߞ</day>
							<day type="wed">ߞ</day>
							<day type="thu">ߓ</day>
							<day type="fri">ߛ</day>
							<day type="sat">ߞ</day>
						</dayWidth>
						<dayWidth type="short">
							<day type="sun">ߞߊ߯</day>
							<day type="mon">ߞߐ߬ߓ</day>
							<day type="tue">ߞߐ߬ߟ</day>
							<day type="wed">ߞߎ</day>
							<day type="thu">ߓߌ</day>
							<day type="fri">ߛߌ߬</day>
							<day type="sat">ߞߍ߲</day>
						</dayWidth>
					</dayContext>
				</days>
				<quarters>
					<quarterContext type="format">
						<quarterWidth type="abbreviated">
							<quarter type="1">ߞߛ߁</quarter>
							<quarter type="2">ߞߛ߂</quarter>
							<quarter type="3">ߞߛ߃</quarter>
							<quarter type="4">ߞߛ߄</quarter>
						</quarterWidth>
						<quarterWidth type="wide">
							<quarter type="1">ߞߊߙߏߛߓߊ߫ ߁߭</quarter>
							<quarter type="2">ߞߊߙߏߛߓߊ߫ ߂߲</quarter>
							<quarter type="3">ߞߊߙߏߛߓߊ߫ ߃߲</quarter>
							<quarter type="4">ߞߊߙߏߛߓߊ߫ ߄߲</quarter>
						</quarterWidth>
					</quarterContext>
					<quarterContext type="stand-alone">
						<quarterWidth type="narrow">
							<quarter type="1">߁</quarter>
							<quarter type="2">߂</quarter>
							<quarter type="3">߃</quarter>
							<quarter type="4">߄</quarter>
						</quarterWidth>
					</quarterContext>
				</quarters>
				<dayPeriods>
					<dayPeriodContext type="format">
						<dayPeriodWidth type="abbreviated">
							<dayPeriod type="am">ߛ</dayPeriod>
							<dayPeriod type="pm">ߥ</dayPeriod>
						</dayPeriodWidth>
					</dayPeriodContext>
				</dayPeriods>
				<eras>
					<eraNames>
						<era type="0">ߌߛߊ߫ ߡߏߦߌ ߢߍ߫</era>
						<era type="0" alt="variant">ߞߊ߬ߝߏ߬ߙߋ߲ ߥߎ߬ߛߎ ߢߍ߫</era>
						<era type="1">ߌߛߊ߫ ߡߏߦߌ ߞߐ߫</era>
						<era type="1" alt="variant">ߞߊ߬ߝߏ߬ߙߋ߲ ߠߊ߫ ߥߎ߬ߛߎ</era>
					</eraNames>
					<eraAbbr>
						<era type="0">ߌߛ. ߡ. ߢߍ߫</era>
						<era type="1">ߌߛ. ߡ. ߞߐ߫</era>
					</eraAbbr>
					<eraNarrow>
						<era type="0">ߌߛ. ߢߍ߫</era>
						<era type="1">ߌߛ. ߞߐ߫</era>
					</eraNarrow>
				</eras>
				<dateTimeFormats>
					<availableFormats>
						<dateFormatItem id="yMd">y / dd / MM</dateFormatItem>
						<dateFormatItem id="yMMMd">y / dd MMM</dateFormatItem>
					</availableFormats>
				</dateTimeFormats>
			</calendar>
		</calendars>
		<fields>
			<field type="era">
				<displayName>ߕߎ߬ߡߊ</displayName>
			</field>
			<field type="era-short">
				<displayName>ߕߎ߬ߡߊ</displayName>
			</field>
			<field type="era-narrow">
				<displayName>ߕߎ߬ߡߊ</displayName>
			</field>
			<field type="year">
				<displayName>ߛߊ߲߭</displayName>
				<relative type="-1">ߛߊߙߏ߲߬</relative>
				<relative type="0">ߢߌ߬ߣߊ߲߬</relative>
				<relative type="1">ߛߊ߲߬ߘߐ߫</relative>
			</field>
			<field type="year-short">
				<displayName>ߛߊ߲߭</displayName>
				<relative type="-1">ߛߊ߲߬ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߢߌ߬ߣߊ߲߬</relative>
				<relative type="1">ߛߊ߲߬ߘߐ</relative>
			</field>
			<field type="year-narrow">
				<displayName>ߛߊ߲߭</displayName>
				<relative type="-1">ߛߊ߲߬ߘߐ߫</relative>
				<relative type="0">ߢߌ߬ߣߊ߲߬</relative>
				<relative type="1">ߛߊ߲߬ߘߐ߫</relative>
			</field>
			<field type="quarter">
				<displayName>ߣߊ߯ߣߌ߲ߢߐ߲߮</displayName>
			</field>
			<field type="month">
				<displayName>ߞߊߙߏ</displayName>
				<relative type="-1">ߞߊߙߏ߫ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߞߊߙߏ ߣߌ߲߬</relative>
				<relative type="1">ߞߊߙߏ߫ ߣߊ߬ߕߐ</relative>
			</field>
			<field type="month-short">
				<displayName>ߞߊߙߏ</displayName>
				<relative type="-1">ߞߊߙߏ߫ ߕߊߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߞߊߙߏ ߣߌ߲߬</relative>
				<relative type="1">ߞߊߙߏ߫ ߣߊ߬ߕߐ</relative>
			</field>
			<field type="month-narrow">
				<displayName>ߞߊߙߏ</displayName>
				<relative type="-1">ߞߊߙߏ߫ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߞߊߙߏ ߣߌ߲߬</relative>
				<relative type="1">ߞߊߙߏ߫ ߣߊ߬ߕߐ</relative>
			</field>
			<field type="week">
				<displayName>ߟߐ߯ߕߍ</displayName>
				<relative type="-1">ߟߐ߯ߕߍ߫ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߟߐ߯ߕߍ ߣߌ߲߬</relative>
				<relative type="1">ߟߐ߯ߕߍ߫ ߣߊ߬ߕߐ</relative>
			</field>
			<field type="week-short">
				<relative type="-1">ߟߐ߯ߕߍ߫ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߟߐ߯ߕߍ ߣߌ߲߬</relative>
				<relative type="1">ߟߐ߯ߕߍ߫ ߣߊ߬ߕߐ</relative>
				<relativePeriod>ߞߊ߬ ߓߐ߫ ߟߐ߯ߕߍ߫ {0}</relativePeriod>
			</field>
			<field type="week-narrow">
				<relative type="-1">ߟߐ߯ߕߍ߫ ߕߊ߬ߡߌ߲߬ߣߍ߲</relative>
				<relative type="0">ߟߐ߯ߕߍ ߣߌ߲߬</relative>
				<relative type="1">ߟߐ߯ߕߍ߫ ߣߊ߬ߕߐ</relative>
				<relativePeriod>ߞߊ߬ߓߐ߫ ߟߐ߯ߕߍ {0}</relativePeriod>
			</field>
			<field type="day">
				<displayName>ߟߏ߲</displayName>
				<relative type="-1">ߞߎߣߎ߲߬</relative>
				<relative type="0">ߓߌ߬</relative>
				<relative type="1">ߛߌߣߌ߲߫</relative>
			</field>
			<field type="day-short">
				<displayName>ߟߏ߲</displayName>
				<relative type="-1">ߞߎߣߎ߲߬</relative>
				<relative type="0">ߓߌ߬</relative>
				<relative type="1">ߛߌߣߌ߲߫</relative>
			</field>
			<field type="day-narrow">
				<displayName>ߟߏ߲</displayName>
				<relative type="-1">ߞߎߣߎ߲߬</relative>
				<relative type="0">ߓߌ߬</relative>
				<relative type="1">ߛߌߣߌ߲߫</relative>
				<relativeTime type="past">
					<relativeTimePattern count="other">ߊ߬ ߟߐ߯ߕߍ߫ {0} ߟߋ߫ ߣߌ߲߬</relativeTimePattern>
				</relativeTime>
			</field>
			<field type="weekday">
				<displayName>ߟߐ߯ߕߍ ߟߏ߲ ߠߎ߬</displayName>
			</field>
			<field type="dayperiod-short">
				<displayName>ߛ/ߥ</displayName>
			</field>
			<field type="dayperiod">
				<displayName>ߛ/ߥ</displayName>
			</field>
			<field type="dayperiod-narrow">
				<displayName>ߛ/ߥ</displayName>
			</field>
			<field type="hour">
				<displayName>ߕߎ߬ߡߊ߬ߙߋ߲</displayName>
			</field>
			<field type="hour-short">
				<displayName>ߕ.</displayName>
			</field>
			<field type="hour-narrow">
				<displayName>ߕ.</displayName>
			</field>
			<field type="minute">
				<displayName>ߡߌ߬ߛߍ߲</displayName>
			</field>
			<field type="minute-short">
				<displayName>ߡ.</displayName>
			</field>
			<field type="minute-narrow">
				<displayName>ߡ.</displayName>
			</field>
			<field type="second">
				<displayName>ߝߌ߬ߟߊ߲</displayName>
			</field>
			<field type="second-short">
				<displayName>ߝ.</displayName>
			</field>
			<field type="second-narrow">
				<displayName>ߝ.</displayName>
			</field>
			<field type="zone">
				<displayName>ߝߊ߲߬ߕߙߊ߬ ߕߎߡߊ</displayName>
			</field>
		</fields>
		<timeZoneNames>
			<gmtFormat>ߜ߭ߕߖ{0}</gmtFormat>
			<gmtZeroFormat>ߜ߭ߕߖ</gmtZeroFormat>
			<regionFormat>{0} ߕߎ߬ߡߊ</regionFormat>
			<regionFormat type="daylight">{0} ߕߎ߬ߡߊ߬-ߦߟߍߡߊ߲</regionFormat>
			<regionFormat type="standard">{0} ߕߎ߬ߡߊ߬-ߦߟߍߡߊ߲ߓߊߟߌ</regionFormat>
			<zone type="Etc/UTC">
				<long>
					<standard>ߖߊ߯ߓߊ߫ ߕߎߡߘߊ߫ ߘߏ߲߬ߖߟߎ߬ߡߊ߬ߣߍ߲</standard>
				</long>
			</zone>
			<zone type="Etc/Unknown">
				<exemplarCity>ߛߏ߫ ߟߐ߲ߓߊߟߌ߫</exemplarCity>
			</zone>
			<zone type="Europe/Andorra">
				<exemplarCity>ߊ߲ߘߏߙߋ߫</exemplarCity>
			</zone>
			<zone type="Asia/Dubai">
				<exemplarCity>ߘߎ߬ߓߊߦߌ߬</exemplarCity>
			</zone>
			<zone type="Asia/Kabul">
				<exemplarCity>ߞߊߓߎߟ</exemplarCity>
			</zone>
			<zone type="America/Antigua">
				<exemplarCity>ߊ߲ߕߌߜ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="America/Anguilla">
				<exemplarCity>ߊ߲ߜ߭ߌߟߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Tirane">
				<exemplarCity>ߕߌߙߣߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Yerevan">
				<exemplarCity>ߦߙߋߝ߭ߊ߲߫</exemplarCity>
			</zone>
			<zone type="Africa/Luanda">
				<exemplarCity>ߟߎߥߊ߲ߘߊ߫</exemplarCity>
			</zone>
			<zone type="Antarctica/Rothera">
				<exemplarCity>ߙߏߕߋߙߊ߫</exemplarCity>
			</zone>
			<zone type="Antarctica/Palmer">
				<exemplarCity>ߔߊߟߑߡߍߙ</exemplarCity>
			</zone>
			<zone type="Antarctica/Troll">
				<exemplarCity>ߕߙߏߟ</exemplarCity>
			</zone>
			<zone type="Antarctica/Syowa">
				<exemplarCity>ߛߏߥߊ߫</exemplarCity>
			</zone>
			<zone type="Antarctica/Mawson">
				<exemplarCity>ߡߊߥߑߛߐ߲߫</exemplarCity>
			</zone>
			<zone type="Antarctica/Davis">
				<exemplarCity>ߘߊߝ߭ߌߛ</exemplarCity>
			</zone>
			<zone type="Antarctica/Vostok">
				<exemplarCity>ߝ߭ߏߛߑߕߏߞ</exemplarCity>
			</zone>
			<zone type="Antarctica/Casey">
				<exemplarCity>ߞߊߛߋߦߌ߫ ߕߎ߬ߡߊ߬ߘߊ</exemplarCity>
			</zone>
			<zone type="Antarctica/DumontDUrville">
				<exemplarCity>ߘߎߡߐ߲-ߎߙߑߝ߭ߌߟ</exemplarCity>
			</zone>
			<zone type="Antarctica/McMurdo">
				<exemplarCity>ߡߞߑߡߎߙߑߘߏ߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/Rio_Gallegos">
				<exemplarCity>ߙߌߦߏ߫ ߜ߭ߊߟߟߋߜ߭ߐߛ</exemplarCity>
			</zone>
			<zone type="America/Mendoza">
				<exemplarCity>ߡߊ߲ߘߏߖ߭ߊ</exemplarCity>
			</zone>
			<zone type="America/Argentina/San_Juan">
				<exemplarCity>ߛߊ߲߫ ߖߎߥߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/Ushuaia">
				<exemplarCity>ߎߛߑߥߦߊ߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/La_Rioja">
				<exemplarCity>ߟߊ ߙߌߦߏߖߊ߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/San_Luis">
				<exemplarCity>ߛߊ߲߫ ߟߎߥߌߛ</exemplarCity>
			</zone>
			<zone type="America/Catamarca">
				<exemplarCity>ߞߕߊߡߊߙߑߞߊ߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/Salta">
				<exemplarCity>ߛߊߟߑߕߊ߫</exemplarCity>
			</zone>
			<zone type="America/Jujuy">
				<exemplarCity>ߖߎߖߎߦߌ߫</exemplarCity>
			</zone>
			<zone type="America/Argentina/Tucuman">
				<exemplarCity>ߕߞߎߡߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Cordoba">
				<exemplarCity>ߞߐߙߑߘߏߓߊ߫</exemplarCity>
			</zone>
			<zone type="America/Buenos_Aires">
				<exemplarCity>ߓߌߦߣߏߛߍߙ</exemplarCity>
			</zone>
			<zone type="Pacific/Pago_Pago">
				<exemplarCity>ߔߊߜ߭ߏ߫ ߡߏߜ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="Europe/Vienna">
				<exemplarCity>ߝ߭ߌߦߍߣ</exemplarCity>
			</zone>
			<zone type="Australia/Perth">
				<exemplarCity>ߔߍߙߕ</exemplarCity>
			</zone>
			<zone type="Australia/Eucla">
				<exemplarCity>ߋߞߑߟߊ߫</exemplarCity>
			</zone>
			<zone type="Australia/Darwin">
				<exemplarCity>ߘߊߙߑߥߌ߲߫</exemplarCity>
			</zone>
			<zone type="Australia/Adelaide">
				<exemplarCity>ߊߘߋߟߊߦߘ</exemplarCity>
			</zone>
			<zone type="Australia/Broken_Hill">
				<exemplarCity>ߓߑߙߏߞߍ߲߫ ߤߌߟ</exemplarCity>
			</zone>
			<zone type="Australia/Melbourne">
				<exemplarCity>ߡߋߟߑߓߎߙߣ</exemplarCity>
			</zone>
			<zone type="Australia/Hobart">
				<exemplarCity>ߤߏߓߊߙߕ</exemplarCity>
			</zone>
			<zone type="Australia/Lindeman">
				<exemplarCity>ߟߌ߲ߘߋߡߊ߲߫</exemplarCity>
			</zone>
			<zone type="Australia/Sydney">
				<exemplarCity>ߛߌߘߑߣߋ߫</exemplarCity>
			</zone>
			<zone type="Australia/Brisbane">
				<exemplarCity>ߓߑߙߌߛߑߓߊ߲߫</exemplarCity>
			</zone>
			<zone type="Antarctica/Macquarie">
				<exemplarCity>ߡߞߊߙߌ߫</exemplarCity>
			</zone>
			<zone type="Australia/Lord_Howe">
				<exemplarCity>ߟߐߙߘ ߤߏߥߋ߫</exemplarCity>
			</zone>
			<zone type="America/Aruba">
				<exemplarCity>ߊߙߎߓߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Mariehamn">
				<exemplarCity>ߡߊߙߌߤߊߡ</exemplarCity>
			</zone>
			<zone type="Asia/Baku">
				<exemplarCity>ߓߊߞߎ߫</exemplarCity>
			</zone>
			<zone type="Europe/Sarajevo">
				<exemplarCity>ߛߙߊߖ߭ߋߝ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="America/Barbados">
				<exemplarCity>ߓߊߙߑߓߘ</exemplarCity>
			</zone>
			<zone type="Asia/Dhaka">
				<exemplarCity>ߘߞߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Brussels">
				<exemplarCity>ߓߑߙߎߞߑߛߍߟ</exemplarCity>
			</zone>
			<zone type="Africa/Ouagadougou">
				<exemplarCity>ߥߜ߭ߊ߬ߘߜ߭ߎ߫</exemplarCity>
			</zone>
			<zone type="Europe/Sofia">
				<exemplarCity>ߛߏߝߌߦߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Bahrain">
				<exemplarCity>ߓߤߊߙߍ߲߫</exemplarCity>
			</zone>
			<zone type="Africa/Bujumbura">
				<exemplarCity>ߓߎߖ߭ߎ߲ߓߎߙߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Porto-Novo">
				<exemplarCity>ߔߐߙߑߕߏ߫-ߣߝ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="America/St_Barthelemy">
				<exemplarCity>ߛߍ߲-ߓߊߙߕߑߤߟߋߡߌ߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Bermuda">
				<exemplarCity>ߓߍߙ߸ߡߎߘߍߛ</exemplarCity>
			</zone>
			<zone type="Asia/Brunei">
				<exemplarCity>ߓߙߎߣߋߦߌ߫</exemplarCity>
			</zone>
			<zone type="America/La_Paz">
				<exemplarCity>ߟߊ ߔߊߖ߭</exemplarCity>
			</zone>
			<zone type="America/Kralendijk">
				<exemplarCity>ߞߑߙߊߟߊ߲ߘߌߖߞ</exemplarCity>
			</zone>
			<zone type="America/Eirunepe">
				<exemplarCity>ߋߙߎߣߔߋ</exemplarCity>
			</zone>
			<zone type="America/Rio_Branco">
				<exemplarCity>ߙߌߦߏ߫ ߓߑߙߊ߲ߞߏ߫</exemplarCity>
			</zone>
			<zone type="America/Porto_Velho">
				<exemplarCity>ߔߐߙߑߕߏ߫ ߝ߭ߋߟߏ߫</exemplarCity>
			</zone>
			<zone type="America/Boa_Vista">
				<exemplarCity>ߓߏߥߊ߫ ߝ߭ߌߛߑߕߊ߫</exemplarCity>
			</zone>
			<zone type="America/Manaus">
				<exemplarCity>ߡߣߊߥߐߛ</exemplarCity>
			</zone>
			<zone type="America/Cuiaba">
				<exemplarCity>ߞߎߦߌߦߓߊ߫</exemplarCity>
			</zone>
			<zone type="America/Santarem">
				<exemplarCity>ߛߊ߲ߕߊߙߍߡ</exemplarCity>
			</zone>
			<zone type="America/Campo_Grande">
				<exemplarCity>ߞߊ߲ߔߏ߫ ߜ߭ߑߙߊ߲ߘ</exemplarCity>
			</zone>
			<zone type="America/Belem">
				<exemplarCity>ߓߟߋߡ</exemplarCity>
			</zone>
			<zone type="America/Araguaina">
				<exemplarCity>ߊߙߊߜ߭ߎߥߊߦߌߣߊ߫ ߕߎ߬ߡߊ߬ߘߊ</exemplarCity>
			</zone>
			<zone type="America/Sao_Paulo">
				<exemplarCity>ߛߊ߲ߔߊߥߟߏ߫</exemplarCity>
			</zone>
			<zone type="America/Bahia">
				<exemplarCity>ߓߊߤߌߦߊ߫</exemplarCity>
			</zone>
			<zone type="America/Fortaleza">
				<exemplarCity>ߝߐߙߑߕߊߟߋߖ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="America/Maceio">
				<exemplarCity>ߡߊߛߋߦߏ߫</exemplarCity>
			</zone>
			<zone type="America/Recife">
				<exemplarCity>ߙߋߛߌߝ</exemplarCity>
			</zone>
			<zone type="America/Noronha">
				<exemplarCity>ߣߐߙߐ߲ߤߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Nassau">
				<exemplarCity>ߣߊߛߊߥߏ߫</exemplarCity>
			</zone>
			<zone type="Asia/Thimphu">
				<exemplarCity>ߕߌ߲ߔߎ߫</exemplarCity>
			</zone>
			<zone type="Africa/Gaborone">
				<exemplarCity>ߜ߭ߊߓߏߙߐߣ</exemplarCity>
			</zone>
			<zone type="Europe/Minsk">
				<exemplarCity>ߡߌ߲ߛߞ</exemplarCity>
			</zone>
			<zone type="America/Belize">
				<exemplarCity>ߓߋߟߋߌߖ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="America/Dawson">
				<exemplarCity>ߘߊߥߎߛߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/Whitehorse">
				<exemplarCity>ߥߌߕߋߤߐߙߛ</exemplarCity>
			</zone>
			<zone type="America/Inuvik">
				<exemplarCity>ߌߣߎߝ߭ߌߞ</exemplarCity>
			</zone>
			<zone type="America/Vancouver">
				<exemplarCity>ߝ߭ߊ߲ߞߎߝ߭ߍߙ</exemplarCity>
			</zone>
			<zone type="America/Fort_Nelson">
				<exemplarCity>ߝߐߙߕ ߣߋߟߑߛߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/Dawson_Creek">
				<exemplarCity>ߘߊߥߎߛߐ߲߫ ߞߙߌߞ</exemplarCity>
			</zone>
			<zone type="America/Creston">
				<exemplarCity>ߞߙߌߛߑߕߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/Edmonton">
				<exemplarCity>ߋߘߑߡߐ߲ߕߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/Swift_Current">
				<exemplarCity>ߛߥߌߝ ߞߎߙߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Cambridge_Bay">
				<exemplarCity>ߞߊ߲ߓߙߌߘߖ ߓߊߦ</exemplarCity>
			</zone>
			<zone type="America/Regina">
				<exemplarCity>ߙߋߖ߭ߌߣߊ߫</exemplarCity>
			</zone>
			<zone type="America/Winnipeg">
				<exemplarCity>ߥߌ߲ߣߌߔߋߜ߭</exemplarCity>
			</zone>
			<zone type="America/Resolute">
				<exemplarCity>ߙߋߖ߭ߏߟߎߕ</exemplarCity>
			</zone>
			<zone type="America/Rankin_Inlet">
				<exemplarCity>ߙߊ߲ߞߌ߲߫ ߌ߲ߟߍߕ</exemplarCity>
			</zone>
			<zone type="America/Coral_Harbour">
				<exemplarCity>ߊߕߌߞߏߞߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Toronto">
				<exemplarCity>ߕߏߙߏ߲ߕߏ߫</exemplarCity>
			</zone>
			<zone type="America/Iqaluit">
				<exemplarCity>ߌߞߊߟߎߦߌߕ</exemplarCity>
			</zone>
			<zone type="America/Moncton">
				<exemplarCity>ߡߐ߲ߞߑߕߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/Halifax">
				<exemplarCity>ߤߊߟߌߝߊߞߛ</exemplarCity>
			</zone>
			<zone type="America/Goose_Bay">
				<exemplarCity>ߜ߭ߏߛߋ߫ ߕߌ߲</exemplarCity>
			</zone>
			<zone type="America/Glace_Bay">
				<exemplarCity>ߜ߭ߑߟߊߛ ߕߌ߲</exemplarCity>
			</zone>
			<zone type="America/Blanc-Sablon">
				<exemplarCity>ߓߑߟߊ߲ߛ-ߛߊߓߑߟߐ߲߫</exemplarCity>
			</zone>
			<zone type="America/St_Johns">
				<exemplarCity>ߛߍ߲-ߖ߭ߊ߲ ߕߋ ߕߍߚ-ߣߋߝ߭</exemplarCity>
			</zone>
			<zone type="Indian/Cocos">
				<exemplarCity>ߞߏߞߏߛ</exemplarCity>
			</zone>
			<zone type="Africa/Kinshasa">
				<exemplarCity>ߞߌ߲ߛߊߛߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Lubumbashi">
				<exemplarCity>ߟߎߓߎ߲ߓߊߛߌ߫</exemplarCity>
			</zone>
			<zone type="Africa/Bangui">
				<exemplarCity>ߓߊ߲ߜ߭ߌ߫</exemplarCity>
			</zone>
			<zone type="Africa/Brazzaville">
				<exemplarCity>ߓߙߖ߭ߊߝ߭ߌߟ</exemplarCity>
			</zone>
			<zone type="Europe/Zurich">
				<exemplarCity>ߖ߭ߎߙߌߞ</exemplarCity>
			</zone>
			<zone type="Africa/Abidjan">
				<exemplarCity>ߊߓߌߖߊ߲߬</exemplarCity>
			</zone>
			<zone type="Pacific/Rarotonga">
				<exemplarCity>ߙߊߙߏߕߏ߲ߜ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Easter">
				<exemplarCity>ߍߛߑߕߍߙ</exemplarCity>
			</zone>
			<zone type="America/Punta_Arenas">
				<exemplarCity>ߔߎ߲ߕߊ߫ ߊߙߋߣߊ߫</exemplarCity>
			</zone>
			<zone type="America/Santiago">
				<exemplarCity>ߛߊ߲ߕߌߦߊߜ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Douala">
				<exemplarCity>ߘߎߥߟߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Urumqi">
				<exemplarCity>ߎߙߎ߲ߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Shanghai">
				<exemplarCity>ߛߊ߲ߜ߭ߊߦߌ߫</exemplarCity>
			</zone>
			<zone type="America/Bogota">
				<exemplarCity>ߓߜ߭ߏߕߊ߫</exemplarCity>
			</zone>
			<zone type="America/Costa_Rica">
				<exemplarCity>ߞߏߛߑߕߊߙߌߞߊ߫</exemplarCity>
			</zone>
			<zone type="America/Havana">
				<exemplarCity>ߤߝ߭ߊߣߊ߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Cape_Verde">
				<exemplarCity>ߜߦߋߞߎ߲߫-ߝߙߌߛߌ߫</exemplarCity>
			</zone>
			<zone type="America/Curacao">
				<exemplarCity>ߞߎߙߛߊߥߏ߫</exemplarCity>
			</zone>
			<zone type="Indian/Christmas">
				<exemplarCity>ߞߙߌߛߑߡߊߛ</exemplarCity>
			</zone>
			<zone type="Asia/Nicosia">
				<exemplarCity>ߣߌߞߏߛߌߦߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Famagusta">
				<exemplarCity>ߝߡߊߜ߭ߎߛߑߕߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Prague">
				<exemplarCity>ߔߙߊߜ߭</exemplarCity>
			</zone>
			<zone type="Europe/Busingen">
				<exemplarCity>ߓߎߛߍ߲ߜ߭ߍ߲߫</exemplarCity>
			</zone>
			<zone type="Europe/Berlin">
				<exemplarCity>ߓߍߙߑߟߍ߲߫</exemplarCity>
			</zone>
			<zone type="Africa/Djibouti">
				<exemplarCity>ߖߌߓߎߕߌ߫</exemplarCity>
			</zone>
			<zone type="Europe/Copenhagen">
				<exemplarCity>ߞߏߔߋߣߊߜ߭</exemplarCity>
			</zone>
			<zone type="America/Dominica">
				<exemplarCity>ߘߏߡߋߣߌߞ</exemplarCity>
			</zone>
			<zone type="America/Santo_Domingo">
				<exemplarCity>ߛߊ߲ߕߏ-ߘߏߡߌ߲ߜ߭</exemplarCity>
			</zone>
			<zone type="Africa/Algiers">
				<exemplarCity>ߊߟߑߖ߭ߋ</exemplarCity>
			</zone>
			<zone type="Pacific/Galapagos">
				<exemplarCity>ߜ߭ߟߊߔߊߜ߭ߐߛ</exemplarCity>
			</zone>
			<zone type="America/Guayaquil">
				<exemplarCity>ߜ߭ߎߥߦߊߞߌߟ</exemplarCity>
			</zone>
			<zone type="Europe/Tallinn">
				<exemplarCity>ߕߊߟߌ߲ߣ</exemplarCity>
			</zone>
			<zone type="Africa/Cairo">
				<exemplarCity>ߞߍ߯ߙ</exemplarCity>
			</zone>
			<zone type="Africa/El_Aaiun">
				<exemplarCity>ߟߊ߯ߦߎߣ</exemplarCity>
			</zone>
			<zone type="Africa/Asmera">
				<exemplarCity>ߊߛߑߡߙߊ߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Canary">
				<exemplarCity>ߞߣߊߙߌ߫</exemplarCity>
			</zone>
			<zone type="Africa/Ceuta">
				<exemplarCity>ߛߋߥߎߕߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Madrid">
				<exemplarCity>ߡߊߘߙߌߘ</exemplarCity>
			</zone>
			<zone type="Africa/Addis_Ababa">
				<exemplarCity>ߊ߬ߘߌ߫ ߛߊ߬ߓߋߓߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Helsinki">
				<exemplarCity>ߤߍߟߑߛߌ߲ߞߌ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Fiji">
				<exemplarCity>ߝߖߌ߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Stanley">
				<exemplarCity>ߛߑߕߊ߲ߟߋߦ</exemplarCity>
			</zone>
			<zone type="Pacific/Truk">
				<exemplarCity>ߗߎ߯ߞ</exemplarCity>
			</zone>
			<zone type="Pacific/Ponape">
				<exemplarCity>ߝߏ߲ߔߋߦߌ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Kosrae">
				<exemplarCity>ߞߐߛ.ߙߊ߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Faeroe">
				<exemplarCity>ߝߊߙߏߋ߫</exemplarCity>
			</zone>
			<zone type="Europe/Paris">
				<exemplarCity>ߔߊ߬ߙߌ߫</exemplarCity>
			</zone>
			<zone type="Africa/Libreville">
				<exemplarCity>ߟߌߓߙߋߝ߭ߌߟ</exemplarCity>
			</zone>
			<zone type="Europe/London">
				<long>
					<daylight>ߓߙߌߕߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
				<exemplarCity>ߟߐ߲ߘߙߍߛ</exemplarCity>
			</zone>
			<zone type="America/Grenada">
				<exemplarCity>ߜ߭ߙߋߣߘߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Tbilisi">
				<exemplarCity>ߕߓߌߟߛߌ߫</exemplarCity>
			</zone>
			<zone type="America/Cayenne">
				<exemplarCity>ߞߊߦߑߣߋ߫</exemplarCity>
			</zone>
			<zone type="Europe/Guernsey">
				<exemplarCity>ߜ߭ߍߙߑߣߛߋߦ</exemplarCity>
			</zone>
			<zone type="Africa/Accra">
				<exemplarCity>ߊߞߙߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Gibraltar">
				<exemplarCity>ߖ߭ߌߓߙߊߟߑߕߊ߫</exemplarCity>
			</zone>
			<zone type="America/Thule">
				<exemplarCity>ߕߎߟߋ߫</exemplarCity>
			</zone>
			<zone type="America/Godthab">
				<exemplarCity>ߣߎ߯ߞ</exemplarCity>
			</zone>
			<zone type="America/Scoresbysund">
				<exemplarCity>ߌߕߕߏߞߞߏߙߑߕߏߙߑߟߜߕ</exemplarCity>
			</zone>
			<zone type="America/Danmarkshavn">
				<exemplarCity>ߘߊ߲ߡߊߙߞߛߑߤߊߝ߭ߣ</exemplarCity>
			</zone>
			<zone type="Africa/Banjul">
				<exemplarCity>ߓߊ߲ߖߎߟ</exemplarCity>
			</zone>
			<zone type="Africa/Conakry">
				<exemplarCity>ߞߐߣߊߞߙߌ߫</exemplarCity>
			</zone>
			<zone type="America/Guadeloupe">
				<exemplarCity>ߜ߭ߑߥߊߘߌߟߎߔ</exemplarCity>
			</zone>
			<zone type="Africa/Malabo">
				<exemplarCity>ߡߟߊߓߏ߫</exemplarCity>
			</zone>
			<zone type="Europe/Athens">
				<exemplarCity>ߊߕߍߣ</exemplarCity>
			</zone>
			<zone type="Atlantic/South_Georgia">
				<exemplarCity>ߞߐ߰ߘߎ߮ ߖ߭ߐߙߑߖ߭ߌߟߊ߫</exemplarCity>
			</zone>
			<zone type="America/Guatemala">
				<exemplarCity>ߜ߭ߊ߬ߕߌ߬ߡߊ߬ߟߊ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Guam">
				<exemplarCity>ߜ߭ߎߥߊ߲߫</exemplarCity>
			</zone>
			<zone type="Africa/Bissau">
				<exemplarCity>ߓߌߛߊߥߏ߫</exemplarCity>
			</zone>
			<zone type="America/Guyana">
				<exemplarCity>ߜ߭ߎߦߣߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Hong_Kong">
				<exemplarCity>ߤߐ߲ߜ߭ ߞߐ߲ߜ߭</exemplarCity>
			</zone>
			<zone type="America/Tegucigalpa">
				<exemplarCity>ߕߋߜ߭ߎߛߌߜ߭ߊߟߑߔߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Zagreb">
				<exemplarCity>ߗ߭ߊߜ߭ߙߍߓ</exemplarCity>
			</zone>
			<zone type="America/Port-au-Prince">
				<exemplarCity>ߔߐߙߕ-ߏ-ߔߑߙߍ߲ߛ</exemplarCity>
			</zone>
			<zone type="Europe/Budapest">
				<exemplarCity>ߓߎߘߊߓߍߛߕ</exemplarCity>
			</zone>
			<zone type="Asia/Jakarta">
				<exemplarCity>ߖߞߊߙߑߕߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Pontianak">
				<exemplarCity>ߔߐ߲ߕߌߦߊߣߊߞ</exemplarCity>
			</zone>
			<zone type="Asia/Makassar">
				<exemplarCity>ߡߞߊߛߊߙ</exemplarCity>
			</zone>
			<zone type="Asia/Jayapura">
				<exemplarCity>ߖߦߊߔߎߙߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Dublin">
				<long>
					<daylight>ߌߙߑߟߊ߲ߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
				<exemplarCity>ߘߎߓߑߟߍ߫</exemplarCity>
			</zone>
			<zone type="Asia/Jerusalem">
				<exemplarCity>ߖ߭ߋߙߎߖ߭ߊߟߍߡ</exemplarCity>
			</zone>
			<zone type="Europe/Isle_of_Man">
				<exemplarCity>ߡߊ߲߫ ߕߌ߲</exemplarCity>
			</zone>
			<zone type="Asia/Calcutta">
				<exemplarCity>ߞߊߟߑߞߎߕߊ߫</exemplarCity>
			</zone>
			<zone type="Indian/Chagos">
				<exemplarCity>ߛߊߜ߭ߐߛ</exemplarCity>
			</zone>
			<zone type="Asia/Baghdad">
				<exemplarCity>ߓߊߜ߭ߑߘߊߘ</exemplarCity>
			</zone>
			<zone type="Asia/Tehran">
				<exemplarCity>ߕߤߋߙߊ߲߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Reykjavik">
				<exemplarCity>ߙߋߦߑߞߌߦߊߝ߭ߍߞ</exemplarCity>
			</zone>
			<zone type="Europe/Rome">
				<exemplarCity>ߙߐߡ</exemplarCity>
			</zone>
			<zone type="Europe/Jersey">
				<exemplarCity>ߖߋߙߑߛߌ߫</exemplarCity>
			</zone>
			<zone type="America/Jamaica">
				<exemplarCity>ߖߡߊߦߌߞߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Amman">
				<exemplarCity>ߊߡߡߊ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Tokyo">
				<exemplarCity>ߕߏߞߌߦߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Nairobi">
				<exemplarCity>ߣߊߦߙߏߓߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Bishkek">
				<exemplarCity>ߓߌߗߍߞ</exemplarCity>
			</zone>
			<zone type="Asia/Phnom_Penh">
				<exemplarCity>ߔߑߣߐ߲߫ ߔߍ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Kanton">
				<exemplarCity>ߞߊ߲ߕߐ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Kiritimati">
				<exemplarCity>ߞߙߌߕߌߡߊߕߌ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Tarawa">
				<exemplarCity>ߕߙߊߥߊ߫</exemplarCity>
			</zone>
			<zone type="Indian/Comoro">
				<exemplarCity>ߞߐߡߐ߯ߙ</exemplarCity>
			</zone>
			<zone type="America/St_Kitts">
				<exemplarCity>ߛߍ߲-ߞߙߌߛߑߕߐߝ</exemplarCity>
			</zone>
			<zone type="Asia/Pyongyang">
				<exemplarCity>ߔߌߦߐ߲ߜ߭ߦߊ߲ߜ߭</exemplarCity>
			</zone>
			<zone type="Asia/Seoul">
				<exemplarCity>ߛߋߎߟ</exemplarCity>
			</zone>
			<zone type="Asia/Kuwait">
				<exemplarCity>ߞߎߥߍߦߌߕ</exemplarCity>
			</zone>
			<zone type="America/Cayman">
				<exemplarCity>ߞߊߦߌߡߊ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Aqtau">
				<exemplarCity>ߊߞߑߕߊߥߎ߫</exemplarCity>
			</zone>
			<zone type="Asia/Oral">
				<exemplarCity>ߏߙߊߟ</exemplarCity>
			</zone>
			<zone type="Asia/Atyrau">
				<exemplarCity>ߊߕߌߙߊߎ߫</exemplarCity>
			</zone>
			<zone type="Asia/Aqtobe">
				<exemplarCity>ߊߞߑߕߏߓߌ߲ߛߞ</exemplarCity>
			</zone>
			<zone type="Asia/Qostanay">
				<exemplarCity>ߞߏߛߑߕߣߊߦ</exemplarCity>
			</zone>
			<zone type="Asia/Qyzylorda">
				<exemplarCity>ߞߖ߭ߌߟߏߙߑߘߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Almaty">
				<exemplarCity>ߊߟߑߡߊ ߊߕߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Vientiane">
				<exemplarCity>ߝ߭ߌߦߍߕߌߣߊߡ</exemplarCity>
			</zone>
			<zone type="Asia/Beirut">
				<exemplarCity>ߓߋߦߌߙߎߕ</exemplarCity>
			</zone>
			<zone type="America/St_Lucia">
				<exemplarCity>ߛߍ-ߟߎߥߌߛ</exemplarCity>
			</zone>
			<zone type="Europe/Vaduz">
				<exemplarCity>ߝ߭߮ߊߘߎߖ߭</exemplarCity>
			</zone>
			<zone type="Asia/Colombo">
				<exemplarCity>ߞߏߟߏ߲ߓߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Monrovia">
				<exemplarCity>ߡߏ߬ߙߏߝ߭ߌߦߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Maseru">
				<exemplarCity>ߡߊߛߋߙߎ߫</exemplarCity>
			</zone>
			<zone type="Europe/Vilnius">
				<exemplarCity>ߝ߭ߌߟߑߣߌߦߎߛ</exemplarCity>
			</zone>
			<zone type="Europe/Luxembourg">
				<exemplarCity>ߟߎߞߑߛߊ߲ߓߎߙߜ߭</exemplarCity>
			</zone>
			<zone type="Europe/Riga">
				<exemplarCity>ߙߌߜ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Tripoli">
				<exemplarCity>ߕߙߌߔߟߌ߫ ( ߟߓߌ߫ )</exemplarCity>
			</zone>
			<zone type="Africa/Casablanca">
				<exemplarCity>ߞߛߊߓߎߟߊ߲ߞߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Monaco">
				<exemplarCity>ߡߏߣߊߞߏ߫</exemplarCity>
			</zone>
			<zone type="Europe/Chisinau">
				<exemplarCity>ߗߛߌߣߊߥ</exemplarCity>
			</zone>
			<zone type="Europe/Podgorica">
				<exemplarCity>ߔߏߘߜ߭ߢߙߌߞߊ߫</exemplarCity>
			</zone>
			<zone type="America/Marigot">
				<exemplarCity>ߡߊߙߌߜ߭ߐߕ</exemplarCity>
			</zone>
			<zone type="Indian/Antananarivo">
				<exemplarCity>ߊ߲ߕߣߊߣߊߙߌߝ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Kwajalein">
				<exemplarCity>ߞߑߥߖߊߟߋߦߌ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Majuro">
				<exemplarCity>ߡߊߖߎߙߏ߫</exemplarCity>
			</zone>
			<zone type="Europe/Skopje">
				<exemplarCity>ߛߑߞߏߔߑߖߋ߫</exemplarCity>
			</zone>
			<zone type="Africa/Bamako">
				<exemplarCity>ߓߡߊ߬ߞߐ߫</exemplarCity>
			</zone>
			<zone type="Asia/Rangoon">
				<exemplarCity>ߙߊ߲ߜ߭ߎ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Hovd">
				<exemplarCity>ߤߏߝ߭ߘ</exemplarCity>
			</zone>
			<zone type="Asia/Ulaanbaatar">
				<exemplarCity>ߎߟߊ߲ߓߊߕߐߙ</exemplarCity>
			</zone>
			<zone type="Asia/Macau">
				<exemplarCity>ߡߞߊߥߏ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Saipan">
				<exemplarCity>ߛߍ߲ߔߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Martinique">
				<exemplarCity>ߡߊߙߑߕߣߌߞ</exemplarCity>
			</zone>
			<zone type="Africa/Nouakchott">
				<exemplarCity>ߣߎߥߊߞߑߛߐߕ</exemplarCity>
			</zone>
			<zone type="America/Montserrat">
				<exemplarCity>ߡߐ߲ߕߛߑߚߊߕ</exemplarCity>
			</zone>
			<zone type="Europe/Malta">
				<exemplarCity>ߡߊߟߑߕ</exemplarCity>
			</zone>
			<zone type="Indian/Mauritius">
				<exemplarCity>ߡߏߙߌߛ</exemplarCity>
			</zone>
			<zone type="Indian/Maldives">
				<exemplarCity>ߡߊߟߑߘߌߝ߭</exemplarCity>
			</zone>
			<zone type="Africa/Blantyre">
				<exemplarCity>ߓߑߟߊ߲ߕߌ߯ߙ</exemplarCity>
			</zone>
			<zone type="America/Tijuana">
				<exemplarCity>ߕߌߖߎߥߣߊ߫</exemplarCity>
			</zone>
			<zone type="America/Hermosillo">
				<exemplarCity>ߤߋߙߑߡߏߛߌߟߏ߫</exemplarCity>
			</zone>
			<zone type="America/Ciudad_Juarez">
				<exemplarCity>ߛߌߦߎߘߊߘ ߖߎߥߊߙߋ߫</exemplarCity>
			</zone>
			<zone type="America/Mazatlan">
				<exemplarCity>ߡߖ߭ߊߕߑߟߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Chihuahua">
				<exemplarCity>ߛߌߤߎߥߊߤߎ߫</exemplarCity>
			</zone>
			<zone type="America/Bahia_Banderas">
				<exemplarCity>ߓߊߤߌߦߊ ߘߋ߬ ߓߊ߲ߘߋߙߊ߫</exemplarCity>
			</zone>
			<zone type="America/Ojinaga">
				<exemplarCity>ߏߖߌߣߜ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="America/Monterrey">
				<exemplarCity>ߡߐ߲ߕߋߚߋߦ</exemplarCity>
			</zone>
			<zone type="America/Mexico_City">
				<exemplarCity>ߡߍߞߛߌߞߏ߫</exemplarCity>
			</zone>
			<zone type="America/Matamoros">
				<exemplarCity>ߡߕߊߡߙߏߛ</exemplarCity>
			</zone>
			<zone type="America/Merida">
				<exemplarCity>ߡߋߙߌߘߊ߫</exemplarCity>
			</zone>
			<zone type="America/Cancun">
				<exemplarCity>ߞߊ߲ߞߎ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Kuala_Lumpur">
				<exemplarCity>ߞߎߥߟߊ ߟߎ߲ߔߎߙ</exemplarCity>
			</zone>
			<zone type="Asia/Kuching">
				<exemplarCity>ߞߎߗߌ߲ߜ߭</exemplarCity>
			</zone>
			<zone type="Africa/Maputo">
				<exemplarCity>ߡߊߔߎߕߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Windhoek">
				<exemplarCity>ߥߌ߲ߘߐߞ</exemplarCity>
			</zone>
			<zone type="Pacific/Noumea">
				<exemplarCity>ߣߎߡߋߦߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Niamey">
				<exemplarCity>ߢߊߡߋ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Norfolk">
				<exemplarCity>ߣߐߙߑߝߐߟߞ</exemplarCity>
			</zone>
			<zone type="Africa/Lagos">
				<exemplarCity>ߟߋߜ߭ߐߛ</exemplarCity>
			</zone>
			<zone type="America/Managua">
				<exemplarCity>ߡߣߊߜ߭ߎߥߊ߫</exemplarCity>
			</zone>
			<zone type="Europe/Amsterdam">
				<exemplarCity>ߊߡߛߑߕߍߙߑߘߊߡ</exemplarCity>
			</zone>
			<zone type="Europe/Oslo">
				<exemplarCity>ߏߛߑߟߏ߫</exemplarCity>
			</zone>
			<zone type="Asia/Katmandu">
				<exemplarCity>ߞߊߕߑߡߊ߲ߘߎ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Nauru">
				<exemplarCity>ߣߊߥߙߎ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Niue">
				<exemplarCity>ߣߌߦߎߋ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Chatham">
				<exemplarCity>ߗߕߊߡ</exemplarCity>
			</zone>
			<zone type="Pacific/Auckland">
				<exemplarCity>ߏߞߑߟߊ߲ߘ</exemplarCity>
			</zone>
			<zone type="Asia/Muscat">
				<exemplarCity>ߡߊߛߑߞߊߕ</exemplarCity>
			</zone>
			<zone type="America/Panama">
				<exemplarCity>ߔߣߊߡߊ߬</exemplarCity>
			</zone>
			<zone type="America/Lima">
				<exemplarCity>ߟߌߡߊ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Tahiti">
				<exemplarCity>ߕߊߤߕߌ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Marquesas">
				<exemplarCity>ߡߊߙߞߌߛ</exemplarCity>
			</zone>
			<zone type="Pacific/Gambier">
				<exemplarCity>ߜ߭ߊ߲ߓߌߦߋߙ</exemplarCity>
			</zone>
			<zone type="Pacific/Port_Moresby">
				<exemplarCity>ߡߏߙߍߛߑߓߌ߫ ߘߊ߲ߞߊ߲</exemplarCity>
			</zone>
			<zone type="Pacific/Bougainville">
				<exemplarCity>ߓߎߜ߭ߍ߲ߝ߭ߌߟ</exemplarCity>
			</zone>
			<zone type="Asia/Manila">
				<exemplarCity>ߡߊߣߌߟ</exemplarCity>
			</zone>
			<zone type="Asia/Karachi">
				<exemplarCity>ߞߙߊߛߌ߫</exemplarCity>
			</zone>
			<zone type="Europe/Warsaw">
				<exemplarCity>ߝ߭ߊߙߑߛߏߝ߭ߌ߫</exemplarCity>
			</zone>
			<zone type="America/Miquelon">
				<exemplarCity>ߡߌߞߋߟߐ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Pitcairn">
				<exemplarCity>ߔߌߕߞߍߙߣ</exemplarCity>
			</zone>
			<zone type="America/Puerto_Rico">
				<exemplarCity>ߔߐߙߕ-ߏ-ߙߌߞߏ߫</exemplarCity>
			</zone>
			<zone type="Asia/Gaza">
				<exemplarCity>ߜ߭ߊߖ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Hebron">
				<exemplarCity>ߤߋߓߑߙߐ߲߫</exemplarCity>
			</zone>
			<zone type="Atlantic/Azores">
				<exemplarCity>ߊߗ߭ߏߙߍߛ</exemplarCity>
			</zone>
			<zone type="Atlantic/Madeira">
				<exemplarCity>ߡߊߘߍߙ</exemplarCity>
			</zone>
			<zone type="Europe/Lisbon">
				<exemplarCity>ߟߌߛߑߓߐ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Palau">
				<exemplarCity>ߔߟߊߏߛ</exemplarCity>
			</zone>
			<zone type="America/Asuncion">
				<exemplarCity>ߊߛߎ߲ߛߌߦߐ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Qatar">
				<exemplarCity>ߞߕߊߙ</exemplarCity>
			</zone>
			<zone type="Indian/Reunion">
				<exemplarCity>ߙߋߣߌߦߐ߲߫</exemplarCity>
			</zone>
			<zone type="Europe/Bucharest">
				<exemplarCity>ߓߎߞߊߙߍߛ</exemplarCity>
			</zone>
			<zone type="Europe/Belgrade">
				<exemplarCity>ߓߍߟߑߜ߭ߙߊߘ</exemplarCity>
			</zone>
			<zone type="Europe/Kaliningrad">
				<exemplarCity>ߞߊߟߌߣߌ߲ߜ߭ߙߊߘ</exemplarCity>
			</zone>
			<zone type="Europe/Moscow">
				<exemplarCity>ߡߏߛߑߞߎ߫</exemplarCity>
			</zone>
			<zone type="Europe/Volgograd">
				<exemplarCity>ߝ߭ߏߟߜ߭ߏߜ߭ߙߊߘ</exemplarCity>
			</zone>
			<zone type="Europe/Saratov">
				<exemplarCity>ߛߙߊߕߐߝ߭</exemplarCity>
			</zone>
			<zone type="Europe/Astrakhan">
				<exemplarCity>ߊߛߑߕߙߊߞߑߤߊ߲߫</exemplarCity>
			</zone>
			<zone type="Europe/Ulyanovsk">
				<exemplarCity>ߎߟߌߦߊߣߏߝ߭ߑߛߞ</exemplarCity>
			</zone>
			<zone type="Europe/Kirov">
				<exemplarCity>ߞߌߙߐߝ߭</exemplarCity>
			</zone>
			<zone type="Europe/Samara">
				<exemplarCity>ߛߡߊߙߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Yekaterinburg">
				<exemplarCity>ߦߋߞߊߕߋߙߌ߲ߓߎߙߜ߭</exemplarCity>
			</zone>
			<zone type="Asia/Omsk">
				<exemplarCity>ߏߡߑߛߞ</exemplarCity>
			</zone>
			<zone type="Asia/Novosibirsk">
				<exemplarCity>ߣߝ߭ߏߞߛߓߌߙߑߛߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Barnaul">
				<exemplarCity>ߓߊߙߑߣߐߟ</exemplarCity>
			</zone>
			<zone type="Asia/Tomsk">
				<exemplarCity>ߕߏߡߑߛߞ</exemplarCity>
			</zone>
			<zone type="Asia/Novokuznetsk">
				<exemplarCity>ߣߝ߭ߏߞߎߖ߭ߣߍߕߑߛߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Krasnoyarsk">
				<exemplarCity>ߞߙߊߛߑߟߏߦߑߦߊߙߑߛߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Irkutsk">
				<exemplarCity>ߌߙߑߞߎߕߑߘߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Chita">
				<exemplarCity>ߗߌߕߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Yakutsk">
				<exemplarCity>ߦߊߞߎߕߑߛߞ</exemplarCity>
			</zone>
			<zone type="Asia/Vladivostok">
				<exemplarCity>ߝ߭ߑߟߊߘߌߝ߭ߏߛߑߕߐߞ</exemplarCity>
			</zone>
			<zone type="Asia/Khandyga">
				<exemplarCity>ߞ߭ߊ߲ߘߌߜ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Sakhalin">
				<exemplarCity>ߛߞߊߟߌߣ</exemplarCity>
			</zone>
			<zone type="Asia/Ust-Nera">
				<exemplarCity>ߎߛߕ-ߣߋߙߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Magadan">
				<exemplarCity>ߡߜ߭ߊߘߊ߲߫</exemplarCity>
			</zone>
			<zone type="Asia/Srednekolymsk">
				<exemplarCity>ߛߙߋߘߑߣߏߞߐߟߌߡߑߛߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Kamchatka">
				<exemplarCity>ߞߊ߲ߦߑߗߊߕߑߞߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Anadyr">
				<exemplarCity>ߊߣߊߘߌߙ</exemplarCity>
			</zone>
			<zone type="Africa/Kigali">
				<exemplarCity>ߞߌߜ߭ߊߟߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Riyadh">
				<exemplarCity>ߙߌߦߊߘ</exemplarCity>
			</zone>
			<zone type="Pacific/Guadalcanal">
				<exemplarCity>ߜ߭ߎߥߘߊߟߑߞߣߊߟ</exemplarCity>
			</zone>
			<zone type="Indian/Mahe">
				<exemplarCity>ߡߊߤߋ߫</exemplarCity>
			</zone>
			<zone type="Africa/Khartoum">
				<exemplarCity>ߞߊߙߑߕߎߡ</exemplarCity>
			</zone>
			<zone type="Europe/Stockholm">
				<exemplarCity>ߛߑߕߏߞߐߟߡ</exemplarCity>
			</zone>
			<zone type="Asia/Singapore">
				<exemplarCity>ߛߍ߲ߜ߭ߊߔߎߙ</exemplarCity>
			</zone>
			<zone type="Atlantic/St_Helena">
				<exemplarCity>ߛߍ߲ߕ ߤߋߟߍߣ</exemplarCity>
			</zone>
			<zone type="Europe/Ljubljana">
				<exemplarCity>ߟߑߖߎߓߑߖߣߊ߫</exemplarCity>
			</zone>
			<zone type="Arctic/Longyearbyen">
				<exemplarCity>ߟߐ߲ߜ߭ߌߋߦߊߙߑߓߌߦߍ߲߫</exemplarCity>
			</zone>
			<zone type="Europe/Bratislava">
				<exemplarCity>ߓߑߙߊߕߌߛߑߟߝ߭ߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Freetown">
				<exemplarCity>ߝߙߌߕߐ߲߬</exemplarCity>
			</zone>
			<zone type="Europe/San_Marino">
				<exemplarCity>ߛߍ߲-ߡߊߙߌߦߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Dakar">
				<exemplarCity>ߘߊ߬ߞߊ߯ߙߎ߫</exemplarCity>
			</zone>
			<zone type="Africa/Mogadishu">
				<exemplarCity>ߡߏߜ߭ߊߘߌߛߏ߫</exemplarCity>
			</zone>
			<zone type="America/Paramaribo">
				<exemplarCity>ߔߙߊߡߊߙߌߓߏ߫</exemplarCity>
			</zone>
			<zone type="Africa/Juba">
				<exemplarCity>ߖߎߓߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Sao_Tome">
				<exemplarCity>ߛߊߏ-ߕߏߡߋ߫</exemplarCity>
			</zone>
			<zone type="America/El_Salvador">
				<exemplarCity>ߛߊߟߑߝ߭ߊߘߐߙ</exemplarCity>
			</zone>
			<zone type="America/Lower_Princes">
				<exemplarCity>ߟߏߥߍ ߔߑߙߍ߲ߛ ߞߊߙߑߕߋ߫</exemplarCity>
			</zone>
			<zone type="Asia/Damascus">
				<exemplarCity>ߘߡߊߛ</exemplarCity>
			</zone>
			<zone type="Africa/Mbabane">
				<exemplarCity>ߒߓߊߓߊߣ</exemplarCity>
			</zone>
			<zone type="America/Grand_Turk">
				<exemplarCity>ߜ߭ߑߙߊ߲ߘ ߕߎߙߞ</exemplarCity>
			</zone>
			<zone type="Africa/Ndjamena">
				<exemplarCity>ߒߖߊߡߋߣߊ߫</exemplarCity>
			</zone>
			<zone type="Indian/Kerguelen">
				<exemplarCity>ߞߍߙߑߜ߭ߋߟߍ߲߫</exemplarCity>
			</zone>
			<zone type="Africa/Lome">
				<exemplarCity>ߟߏߡߋ߫</exemplarCity>
			</zone>
			<zone type="Asia/Bangkok">
				<exemplarCity>ߓߊ߲ߞߐߞ</exemplarCity>
			</zone>
			<zone type="Asia/Dushanbe">
				<exemplarCity>ߘߎߛߊ߲ߓߋ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Fakaofo">
				<exemplarCity>ߝߞߊߏߝߏ߫</exemplarCity>
			</zone>
			<zone type="Asia/Dili">
				<exemplarCity>ߘߟߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Ashgabat">
				<exemplarCity>ߊߛߑߜ߭ߊߓߊߕ</exemplarCity>
			</zone>
			<zone type="Africa/Tunis">
				<exemplarCity>ߕߎߣߌߛ</exemplarCity>
			</zone>
			<zone type="Pacific/Tongatapu">
				<exemplarCity>ߕߏ߲ߜ߭ߕߊߔߎ߫</exemplarCity>
			</zone>
			<zone type="Europe/Istanbul">
				<exemplarCity>ߌߛߑߕߊ߲ߓߎߟ</exemplarCity>
			</zone>
			<zone type="America/Port_of_Spain">
				<exemplarCity>ߔߐߙߕ ߊߛߑߔߊ߲߫</exemplarCity>
			</zone>
			<zone type="Pacific/Funafuti">
				<exemplarCity>ߝߎߣߊߝߎߕߌ߫</exemplarCity>
			</zone>
			<zone type="Asia/Taipei">
				<exemplarCity>ߕߊߦߌߔߋ߫</exemplarCity>
			</zone>
			<zone type="Africa/Dar_es_Salaam">
				<exemplarCity>ߘߊ߯ߙ-ߛߊ߬ߟߊ߯ߡ</exemplarCity>
			</zone>
			<zone type="Europe/Kiev">
				<exemplarCity>ߞߌߦߍߝ߭</exemplarCity>
			</zone>
			<zone type="Europe/Simferopol">
				<exemplarCity>ߛߌ߲ߝߋߙߔߏߟ</exemplarCity>
			</zone>
			<zone type="Africa/Kampala">
				<exemplarCity>ߞߊ߲ߔߟߊ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Midway">
				<exemplarCity>ߡߌߘߑߥߊߦ</exemplarCity>
			</zone>
			<zone type="Pacific/Wake">
				<exemplarCity>ߥߊߞߋ߫</exemplarCity>
			</zone>
			<zone type="America/Adak">
				<exemplarCity>ߊߘߊߞ</exemplarCity>
			</zone>
			<zone type="America/Nome">
				<exemplarCity>ߣߏߡߋ߫</exemplarCity>
			</zone>
			<zone type="America/Anchorage">
				<exemplarCity>ߊ߲ߞߏߙߊߖ߭</exemplarCity>
			</zone>
			<zone type="America/Yakutat">
				<exemplarCity>ߦߊߞߎߕߊ߫</exemplarCity>
			</zone>
			<zone type="America/Sitka">
				<exemplarCity>ߛߌߕߑߞߊ߫</exemplarCity>
			</zone>
			<zone type="America/Juneau">
				<exemplarCity>ߖߎߣߋߥߏ߫</exemplarCity>
			</zone>
			<zone type="America/Metlakatla">
				<exemplarCity>ߡߋߕߑߟߞߊߦߑߟߊ߫</exemplarCity>
			</zone>
			<zone type="America/Los_Angeles">
				<exemplarCity>ߟߐߛ ߊ߲ߖ߭ߋߟߍߛ</exemplarCity>
			</zone>
			<zone type="America/Boise">
				<exemplarCity>ߓߎߥߊߛ</exemplarCity>
			</zone>
			<zone type="America/Phoenix">
				<exemplarCity>ߝߏߋߣߌߞߛ</exemplarCity>
			</zone>
			<zone type="America/Denver">
				<exemplarCity>ߘߊ߲ߝ߭ߍߙ</exemplarCity>
			</zone>
			<zone type="America/North_Dakota/Beulah">
				<exemplarCity>ߓߋߦߎߟߊ߫ (ߞߐ߰ߘߎ߮ ߘߊߞߏߕߊ߫)</exemplarCity>
			</zone>
			<zone type="America/North_Dakota/New_Salem">
				<exemplarCity>ߣߋߥ ߛߊߟߋߡ (ߞߐ߰ߘߎ߮ ߘߊߞߏߕߊ߫)</exemplarCity>
			</zone>
			<zone type="America/North_Dakota/Center">
				<exemplarCity>ߛߊ߲ߕߙߌ߫ (ߞߐ߰ߘߎ߮ ߘߊߞߏߕߊ߫)</exemplarCity>
			</zone>
			<zone type="America/Chicago">
				<exemplarCity>ߛߌߞߊߜ߭ߏ߫</exemplarCity>
			</zone>
			<zone type="America/Menominee">
				<exemplarCity>ߡߋߣߏߡߌ߲߫</exemplarCity>
			</zone>
			<zone type="America/Indiana/Vincennes">
				<exemplarCity>ߝ߭ߍ߲ߛߊ߲߫ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indiana/Petersburg">
				<exemplarCity>ߔߋߕߍߙߛߑߓߎߙߜ߭ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indiana/Tell_City">
				<exemplarCity>ߕߍߟ ߛߕߌ߫ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indiana/Knox">
				<exemplarCity>ߞߑߣߏߞߛ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indiana/Winamac">
				<exemplarCity>ߥߌߣߡߊߞ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indiana/Marengo">
				<exemplarCity>ߡߊߙߌ߲ߜ߭ߏ߫ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Indianapolis">
				<exemplarCity>ߌ߲ߘߌߦߊߣߊߔߏߟߌߛ</exemplarCity>
			</zone>
			<zone type="America/Louisville">
				<exemplarCity>ߟߎߦߌߛߝ߭ߌߟ</exemplarCity>
			</zone>
			<zone type="America/Indiana/Vevay">
				<exemplarCity>ߝ߭ߋߝ߭ߊߦ [ߌ߲ߘߌߦߣߊ߫]</exemplarCity>
			</zone>
			<zone type="America/Kentucky/Monticello">
				<exemplarCity>ߡߐ߲ߕߌߛߋߟߏ߬ [ߞߊ߲ߕߎߞߌ߫]</exemplarCity>
			</zone>
			<zone type="America/Detroit">
				<exemplarCity>ߘߋߕߙߏߥߊ</exemplarCity>
			</zone>
			<zone type="America/New_York">
				<exemplarCity>ߣߋߥ ߦߐߙߞ</exemplarCity>
			</zone>
			<zone type="America/Montevideo">
				<exemplarCity>ߡߐ߲ߕߋߝ߭ߌߘߋߥߏ߫</exemplarCity>
			</zone>
			<zone type="Asia/Samarkand">
				<exemplarCity>ߛߡߊߙߑߞߊ߲ߘ</exemplarCity>
			</zone>
			<zone type="Asia/Tashkent">
				<exemplarCity>ߕߊߛߗߑߞߍ߲ߕ</exemplarCity>
			</zone>
			<zone type="Europe/Vatican">
				<exemplarCity>ߝ߭ߊߕߌߞߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/St_Vincent">
				<exemplarCity>ߛߍ߲-ߝ߭ߍ߲ߛߊ߲߫</exemplarCity>
			</zone>
			<zone type="America/Caracas">
				<exemplarCity>ߞߙߊߞߊߛ</exemplarCity>
			</zone>
			<zone type="America/Tortola">
				<exemplarCity>ߕߏߙߑߕߏߟߊ߫</exemplarCity>
			</zone>
			<zone type="America/St_Thomas">
				<exemplarCity>ߛߍ߲-ߕߏߡߊߛ</exemplarCity>
			</zone>
			<zone type="Asia/Saigon">
				<exemplarCity>ߤߐ߯-ߗߌ-ߡߌ߲-ߘߎ߱</exemplarCity>
			</zone>
			<zone type="Pacific/Efate">
				<exemplarCity>ߋߝߊߕߋ߫</exemplarCity>
			</zone>
			<zone type="Pacific/Wallis">
				<exemplarCity>ߥߊߟߟߌߛ</exemplarCity>
			</zone>
			<zone type="Pacific/Apia">
				<exemplarCity>ߊߔߌߦߊ߫</exemplarCity>
			</zone>
			<zone type="Asia/Aden">
				<exemplarCity>ߊߘߍ߲߫</exemplarCity>
			</zone>
			<zone type="Indian/Mayotte">
				<exemplarCity>ߡߊߦߐߕ</exemplarCity>
			</zone>
			<zone type="Africa/Johannesburg">
				<exemplarCity>ߖ߭ߎߥߊߣߍߛߑߓߎ߯ߙ</exemplarCity>
			</zone>
			<zone type="Africa/Lusaka">
				<exemplarCity>ߟߎߛߞߊ߫</exemplarCity>
			</zone>
			<zone type="Africa/Harare">
				<exemplarCity>ߤߙߊߙߋ߫</exemplarCity>
			</zone>
			<metazone type="Afghanistan">
				<long>
					<standard>ߊߝߑߜ߭ߊߣߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Africa_Central">
				<long>
					<standard>ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߊ߲ߓߊ߲ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
				</long>
			</metazone>
			<metazone type="Africa_Eastern">
				<long>
					<standard>ߝߘߊ߬ߌ߲߬ߠߊ߫ ߓߟߋ߬ߓߐ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
				</long>
			</metazone>
			<metazone type="Africa_Southern">
				<long>
					<standard>ߝߘߌ߬ߝߌ߲߬ߠߊ߫ ߥߙߏ߬ߘߎ߮ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
				</long>
			</metazone>
			<metazone type="Africa_Western">
				<long>
					<generic>ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߟߋ߬ߓߋ ߕߎ߬ߡߊ߬ߙߋ߲</generic>
					<standard>ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߟߋ߬ߓߋ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
					<daylight>ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߟߋ߬ߓߋ ߕߟߋ߬ߡߊ߬ ߕߎߡߊߙߋ߲</daylight>
				</long>
			</metazone>
			<metazone type="Alaska">
				<long>
					<generic>ߊߟߊߛߑߞߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߟߊߛߑߞߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߟߊߛߑߞߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Amazon">
				<long>
					<generic>ߊߡߊߖ߭ߏ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߡߊߖ߭ߏߣ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߡߊߖ߭ߏ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="America_Central">
				<long>
					<generic>ߊߡߋߙߌߞߌ߬ ߕߊ߲ߓߊ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߐ߰ߘߎ߮ ߊߡߋߙߌߞߌ߬ ߕߎ߬ߡߘߊ߬ ߕߊ߲ߓߊ߲߫ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߐ߰ߘߎ߮ ߊߡߋߙߌߞߌ߬ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="America_Eastern">
				<long>
					<generic>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߕߟߋ߬ߓߐ߬ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߕߟߋ߬ߓߐ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="America_Mountain">
				<long>
					<generic>ߞߙߎ߬ߞߊ߲߬ߠߊ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߙߎ߬ߞߊ߲߬ߠߊ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߙߎ߬ߞߊ߲߬ߠߊ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="America_Pacific">
				<long>
					<generic>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߣߌ߫ ߖߐ߫ ߟߌ߲ߓߊ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߣߌ߫ ߖߐ߫ ߟߌ߲ߓߊ߲ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߐ߰ߘߎ߰ ߊߡߋߙߌߞߌ߬ ߣߌ߫ ߖߐ߫ ߟߌ߲ߓߊ߲ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Apia">
				<long>
					<generic>ߊߔߌߦߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߔߌߦߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߔߌߦߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Arabian">
				<long>
					<generic>ߊߙߊߓߎߟߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߙߊߓߎߟߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߙߊߓߎߟߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Argentina">
				<long>
					<generic>ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Argentina_Western">
				<long>
					<generic>ߕߟߋ߬ߓߋ ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߋ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߋ ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Armenia">
				<long>
					<generic>ߊߙߑߡߋߣߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߙߑߡߋߣߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߙߑߡߋߣߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Atlantic">
				<long>
					<generic>ߟߌ߲ߓߊ߲-ߡߊ߲ߞߊ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߟߌ߲ߓߊ߲-ߡߊ߲ߞߊ߲ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߟߌ߲ߓߊ߲-ߡߊ߲ߞߊ߲ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Australia_Central">
				<long>
					<generic>ߕߍߡߟߊ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߍߡߟߊ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߍߡߟߊ ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Australia_CentralWestern">
				<long>
					<generic>ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߓߋ߬-ߕߍߡߟߊ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߓߋ߬-ߕߍߡߟߊ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߓߋ߬-ߕߍߡߟߊ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Australia_Eastern">
				<long>
					<generic>ߕߟߋ߬ߓߐ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߐ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߐ ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Australia_Western">
				<long>
					<generic>ߕߟߋ߬ߓߋ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߋ ߏߛߑߕߙߊߟߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߋ ߏߛߑߕߙߊߟߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Azerbaijan">
				<long>
					<generic>ߊߖ߭ߍߙߑߓߊߦߑߖߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߖ߭ߍߙߑߓߊߦߑߖߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߖ߭ߍߙߑߓߊߦߑߖߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Azores">
				<long>
					<generic>ߊߗ߭ߐߙߛ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߊߗ߭ߐߙߛ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߊߗ߭ߐߙߛ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Bangladesh">
				<long>
					<generic>ߓߊ߲ߜ߭ߑߟߊߘߍߛ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߓߊ߲ߜ߭ߑߟߊߘߍߛ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߓߊ߲ߜ߭ߑߟߊߘߍߛ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Bhutan">
				<long>
					<standard>ߓߎߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Bolivia">
				<long>
					<standard>ߓߏߟߝ߭ߌ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Brasilia">
				<long>
					<generic>ߓߙߋߖ߭ߟߌߟߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߓߙߋߖ߭ߟߌߟߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߓߙߋߖ߭ߟߌߟߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Brunei">
				<long>
					<standard>ߓߙߎߣߋߦߌ߫ ߘߊߙߎߛߑߛߟߊߡ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Cape_Verde">
				<long>
					<generic>ߜߙߋߞߎ߲߫-ߝߙߌߛߌ߫ ߕߎ߬ߡߊ߬ߙߋ߲</generic>
					<standard>ߜߙߋߞߎ߲߫-ߝߙߌߛߌ߫ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
					<daylight>ߜߙߋߞߎ߲߫-ߝߙߌߛߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߊߙߋ߲</daylight>
				</long>
			</metazone>
			<metazone type="Chamorro">
				<long>
					<standard>ߛ߭ߊߡߏߙߏ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
				</long>
			</metazone>
			<metazone type="Chatham">
				<long>
					<generic>ߗߕߊߡ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߗߕߊߡ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߗߕߊߡ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Chile">
				<long>
					<generic>ߛߟߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߛߟߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߛߟߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="China">
				<long>
					<generic>ߛߌߣ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߛߌߣ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߛߌߣ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Christmas">
				<long>
					<standard>ߞߑߙߌߛߑߡߊߛ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Cocos">
				<long>
					<standard>ߞߏߞߏߛ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Colombia">
				<long>
					<generic>ߞߐߟߐ߲ߓߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߐߟߐ߲ߓߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߐߟߐ߲ߓߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Cook">
				<long>
					<generic>ߞߏߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߏߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߏߞ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Cuba">
				<long>
					<generic>ߞߎ߳ߓߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߎ߳ߓߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߎ߱ߓߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Davis">
				<long>
					<standard>ߘߊߝ߭ߌߛ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="DumontDUrville">
				<long>
					<standard>ߘߎߡߐ߲-ߘߎߙߑߝ߭ߌߟ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="East_Timor">
				<long>
					<standard>ߕߟߋ߬ߓߐ ߕߌߡߐߙ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Easter">
				<long>
					<generic>ߌߛߑߟߊ߲ߘ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߌߛߑߟߊ߲ߘ ߕߌ߲ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߌߛߑߟߊ߲ߘ ߕߌ߲ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Ecuador">
				<long>
					<standard>ߌߞߑߥߊߘߐߙ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Europe_Central">
				<long>
					<generic>ߕߍߡߊ߫ ߋߙߐߔߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߍߡߊ߫ ߋߙߐߔߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߍߡߊ߫ ߋߙߐߔߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Europe_Eastern">
				<long>
					<generic>ߕߟߋ߬ߓߐ ߋߙߐߔߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߐ ߋߙߐߔߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߐ ߋߙߐߔߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Europe_Further_Eastern">
				<long>
					<standard>ߞߊߟߌߣߌ߲ߜ߭ߙߊߘ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Europe_Western">
				<long>
					<generic>ߕߟߋ߬ߓߋ ߋߙߐߔߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߋ ߋߙߐߔߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߋ ߋߙߐߔߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Falkland">
				<long>
					<generic>ߝߊߟߞߑߟߊ߲ߘ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝߊߟߞߑߟߊ߲ߘ ߕߌ߲ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝߊߟߞߑߟߊ߲ߘ ߕߌ߲ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Fiji">
				<long>
					<generic>ߝߖߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝߖߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝߖߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="French_Guiana">
				<long>
					<standard>ߝߊ߬ߙߊ߲߬ߛߌ߬ ߜ߭ߎߦߣߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="French_Southern">
				<long>
					<standard>ߐߛߑߕߙߊߟߌ߫ ߘߎ߰ߞߟߏ ߣߌ߫ ߝߊ߬ߙߊ߲߬ߛߌ߫ ߊ߲ߕߊߙߑߕߌߞ ߕߎ߬ߡߊ߬ߙߋ</standard>
				</long>
			</metazone>
			<metazone type="Galapagos">
				<long>
					<standard>ߜ߭ߟߊߔߊߜ߭ߐߛ ߕߎ߬ߡߊ߬ߘߊ߫</standard>
				</long>
			</metazone>
			<metazone type="Gambier">
				<long>
					<standard>ߜ߭ߊ߲ߓߌߦߍߙ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Georgia">
				<long>
					<generic>ߖ߭ߐߙߑߖ߭ߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߖ߭ߐߙߑߖ߭ߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߖ߭ߐߙߑߖ߭ߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Gilbert_Islands">
				<long>
					<standard>ߖ߭ߌߟߑߓߍߙߕ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="GMT">
				<long>
					<standard>ߜ߭ߙߋߣߍߕ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Greenland_Eastern">
				<long>
					<generic>ߕߟߋ߬ߓߐ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߐ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߐ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Greenland_Western">
				<long>
					<generic>ߕߟߋ߬ߓߋ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߟߋ߬ߓߋ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߟߋ߬ߓߋ ߜ߭ߌߙߌ߲ߟߊ߲ߘ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Gulf">
				<long>
					<standard>ߖߌߘߏ߮ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Guyana">
				<long>
					<standard>ߜ߭ߎߦߣߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Hawaii_Aleutian">
				<long>
					<generic>ߤߥߊߦ - ߊߟߋߦߎߕߌߦߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߤߥߊߦ - ߊߟߋߦߎߕߌߦߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߤߥߊߦ - ߊߟߋߦߎߕߌߦߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Hong_Kong">
				<long>
					<generic>ߤߐ߲ߜ߭ ߞߐ߲ߜ߭ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߤߐ߲ߜ߭ ߞߐ߲ߜ߭ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߤߐ߲ߜ߭ ߞߐ߲ߜ߭ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Hovd">
				<long>
					<generic>ߤߏߝ߭ߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߤߏߝ߭ߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߤߏߝ߭ߘ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="India">
				<long>
					<standard>ߤߌ߲ߘߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
				</long>
			</metazone>
			<metazone type="Indian_Ocean">
				<long>
					<standard>ߍ߲ߘߎ߫ ߟߌ߲ߓߊ߲ߘߎ߯ ߕߎ߬ߡߊ߬ߙߋ߲</standard>
				</long>
			</metazone>
			<metazone type="Indochina">
				<long>
					<standard>ߤߌ߲ߘߏ߫ ߛߌߣ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Indonesia_Central">
				<long>
					<standard>ߕߍߡߊ߫ ߍ߲ߘߋߣߏߛߌ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Indonesia_Eastern">
				<long>
					<standard>ߕߟߋ߬ߓߐ ߍ߲ߘߋߣߏߛߌ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Indonesia_Western">
				<long>
					<standard>ߕߟߋ߬ߓߋ ߍ߲ߘߋߣߏߛߌ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Iran">
				<long>
					<generic>ߌߙߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߌߙߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߌߙߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Irkutsk">
				<long>
					<generic>ߌߙߑߞߎߕߑߛߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߌߙߑߞߎߕߑߛߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߌߙߑߞߎߕߑߛߞ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Israel">
				<long>
					<generic>ߌߛߌ߬ߙߊ߬ߦߌߟߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߌߛߌ߬ߙߊ߬ߦߌߟߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߌߛߌ߬ߙߊ߬ߦߌߟߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ ߛߎߡߊ߲ߘߊ߲ߕߊ</daylight>
				</long>
			</metazone>
			<metazone type="Japan">
				<long>
					<generic>ߖ߭ߊߔߐ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߖ߭ߊߔߐ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߖ߭ߊߔߐ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Kazakhstan">
				<long>
					<standard>ߞߖ߭ߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Kazakhstan_Eastern">
				<long>
					<standard>ߕߟߋ߬ߓߐ ߞߖ߭ߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Kazakhstan_Western">
				<long>
					<standard>ߕߟߋ߬ߓߋ ߞߖ߭ߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Korea">
				<long>
					<generic>ߞߏߙߋ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߏߙߋ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߏߙߋ߫ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Kosrae">
				<long>
					<standard>ߞߏߛߑߙߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Krasnoyarsk">
				<long>
					<generic>ߞߙߊߛߑߣߏߦߌߦߊߙߑߛߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߙߊߛߑߣߏߦߌߦߊߙߑߛߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߙߊߛߑߣߏߦߌߦߊߙߑߛߞ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Kyrgystan">
				<long>
					<standard>ߜ߭ߌߙߑߜ߭ߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Line_Islands">
				<long>
					<standard>ߌߛߑߟߊ߲ߘ ߞߍ߬ߙߍ߲߬ߘߍ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Lord_Howe">
				<long>
					<generic>ߟߐߙߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߟߐߙߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߟߐߙߘ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Magadan">
				<long>
					<generic>ߡߜ߭ߊߘߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߡߜ߭ߊߘߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߡߜ߭ߊߘߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Malaysia">
				<long>
					<standard>ߡߊߟߍߘߎ߯ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Maldives">
				<long>
					<standard>ߡߊߟߑߘߌߝ߭ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Marquesas">
				<long>
					<standard>ߡߊߙߞߌߛߊߛ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Marshall_Islands">
				<long>
					<standard>ߡߊߙߑߛߊߟ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Mauritius">
				<long>
					<generic>ߡߏߙߌߛ ߕߎ߬ߡߊ߬ߙߋ߲</generic>
					<standard>ߡߏߙߌߛ ߕߎ߬ߡߊ߬ߙߋ߲ ߢߊߓߘߍ</standard>
					<daylight>ߡߏߙߌߛ ߕߟߋ߬ߡߊ߬ ߕߎߡߊߙߋ߲</daylight>
				</long>
			</metazone>
			<metazone type="Mawson">
				<long>
					<standard>ߡߊߥߑߛߐ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Mexico_Pacific">
				<long>
					<generic>ߖߐ߫ ߟߌ߲ߓߊ߲ ߡߍ߲ߞߛߌߞߌ߬ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߖߐ߫ ߟߌ߲ߓߊ߲ ߡߍ߲ߞߛߌߞߌ߬ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߖߐ߫ ߟߌ߲ߓߊ߲ ߡߍ߲ߞߛߌߞߌ߬ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Mongolia">
				<long>
					<generic>ߎߟߊ߲ߓߕߐߙ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߎߟߊ߲ߓߕߐߙ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߎߟߊ߲ߓߕߐߙ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Moscow">
				<long>
					<generic>ߡߏߛߑߞߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߡߏߛߑߞߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߡߏߛߑߞߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Myanmar">
				<long>
					<standard>ߡߌߦߊߣߑߡߊߙ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Nauru">
				<long>
					<standard>ߣߊߥߙߎ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Nepal">
				<long>
					<standard>ߣߋߔߊߟ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="New_Caledonia">
				<long>
					<generic>ߞߊߟߌߘߏߣߌ߫ ߞߎߘߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߞߊߟߌߘߏߣߌ߫ ߞߎߘߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߞߊߟߌߘߏߣߌ߫ ߞߎߘߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="New_Zealand">
				<long>
					<generic>ߣߌߦߎ-ߖ߭ߋߟߊ߲ߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߣߌߦߎ-ߖ߭ߋߟߊ߲ߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߣߌߦߎ-ߖ߭ߋߟߊ߲ߘ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Newfoundland">
				<long>
					<generic>ߝߎ߲ߘߑߟߊ߲ߘ ߞߎߘߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝߎ߲ߘߑߟߊ߲ߘ ߞߎߘߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝߎ߲ߘߑߟߊ߲ߘ ߞߎߘߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Niue">
				<long>
					<standard>ߣߌߦߋ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Norfolk">
				<long>
					<generic>ߣߐߙ ߝߐߟߞ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߣߐߙ ߝߐߟߞ ߕߌ߲ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߣߐߙ ߝߐߟߞ ߕߌ߲ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Noronha">
				<long>
					<generic>ߝߍߙߑߣߊ߲ߘߏ߫ ߘߋ߬ ߣߏߙߏ߲ߤߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝߍߙߑߣߊ߲ߘߏ߫ ߘߋ߬ ߣߏߙߏ߲ߤߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝߍߙߑߣߊ߲ߘߏ߫ ߘߋ߬ ߣߏߙߏ߲ߤߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Novosibirsk">
				<long>
					<generic>ߣߝ߭ߏߛߓߌߙߑߛߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߣߝ߭ߏߛߓߌߙߑߛߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߣߝ߭ߏߛߓߌߙߑߛߞ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Omsk">
				<long>
					<generic>ߏߡߑߛߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߏߡߑߛߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߏߡߑߛߞ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Pakistan">
				<long>
					<generic>ߔߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߔߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߔߊߞߌߛߑߕߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Palau">
				<long>
					<standard>ߔߟߊߐߛ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Papua_New_Guinea">
				<long>
					<standard>ߔߊߓߎߥߊ߫ ߖߌ߬ߣߍ߬ ߞߎߘߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Paraguay">
				<long>
					<generic>ߔߙߊߜ߭ߎߥߋ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߔߙߊߜ߭ߎߥߋ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߔߙߊߜ߭ߎߥߋ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Peru">
				<long>
					<generic>ߔߋߙߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߔߋߙߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߔߋߙߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Philippines">
				<long>
					<generic>ߝߟߌߔߌ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝߟߌߔߌ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝߟߌߔߌ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Phoenix_Islands">
				<long>
					<standard>ߝߏߣߌߞߛ ߕߌ߲ ߠߎ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Pierre_Miquelon">
				<long>
					<generic>ߛߍ߲-ߔߌߦߍߙ-ߋ-ߡߌߞߋߟߐ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߛߍ߲-ߔߌߦߍߙ-ߋ-ߡߌߞߋߟߐ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߛߍ߲-ߔߌߦߍߙ-ߋ-ߡߌߞߋߟߐ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Pitcairn">
				<long>
					<standard>ߔߌߕߑߞߍߙߣ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Ponape">
				<long>
					<standard>ߔߏ߲ߔߍ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Pyongyang">
				<long>
					<standard>ߔߌߦߐ߲ߜ߭ߦߊ߲ߜ߭ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Reunion">
				<long>
					<standard>ߙߋߣߌߦߐ߲߫ ߕߎ߬ߡߊ߬ߙߋ߲</standard>
				</long>
			</metazone>
			<metazone type="Rothera">
				<long>
					<standard>ߙߏߕߋߙߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Sakhalin">
				<long>
					<generic>ߛߊߞߑߤߊߟߌߣ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߛߊߞߑߤߊߟߌߣ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߛߊߞߑߤߊߟߌߣ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Samoa">
				<long>
					<generic>ߛߊߡߏߥߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߛߊߡߏߥߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߛߊߡߏߥߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Seychelles">
				<long>
					<standard>ߛߋߦߌߛߌߟ ߕߎ߬ߡߊ߬ߙߋ߲</standard>
				</long>
			</metazone>
			<metazone type="Singapore">
				<long>
					<standard>ߛߍ߲ߜ߭ߊߔߎߙ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
				</long>
			</metazone>
			<metazone type="Solomon">
				<long>
					<standard>ߛߟߏ߬ߡߣߊ߬ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="South_Georgia">
				<long>
					<standard>ߥߙߏ߬ߘߎ߮ ߖ߭ߐߙߑߖ߭ߌߟߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Suriname">
				<long>
					<standard>ߛߎߙߌߣߊߡ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Syowa">
				<long>
					<standard>ߛߦߏߥߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Tahiti">
				<long>
					<standard>ߕߊߤߕߌ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Taipei">
				<long>
					<generic>ߕߊߦߌߔߋ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߊߦߌߔߋ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߊߦߌߔߋ߫ ߕߟߋ߬ߡߊ߬ ߕߎ߬ߡߊ߬ߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Tajikistan">
				<long>
					<standard>ߕߊߖߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Tokelau">
				<long>
					<standard>ߕߏߞߋߟߏ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Tonga">
				<long>
					<generic>ߕߏ߲ߜ߭ߊ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߏ߲ߜ߭ߊ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߏ߲ߜ߭ߊ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Truk">
				<long>
					<standard>ߗߎߞ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Turkmenistan">
				<long>
					<generic>ߕߎߙߞߌߡߋߣߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߕߎߙߞߌߡߋߣߌߛߑߕߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߕߎߙߞߑߡߋߣߌߛߑߕߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Tuvalu">
				<long>
					<standard>ߕߎߝ߭ߊߟߎ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Uruguay">
				<long>
					<generic>ߎ߳ߙߑߜ߭ߋߦߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߎ߳ߙߑߜ߭ߋߦߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߎ߳ߙߑߜ߭ߋߦߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Uzbekistan">
				<long>
					<generic>ߏߖ߭ߑߓߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߏߖ߭ߑߓߊߞߌߛߑߕߊ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߏߖ߭ߑߓߊߞߌߛߑߕߊ߲߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Vanuatu">
				<long>
					<generic>ߝ߭ߊߣߎߥߊߕߎ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝ߭ߊߣߎߥߊߕߎ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝ߭ߊߣߎߥߊߕߎ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Venezuela">
				<long>
					<standard>ߝ߭ߣߋߖ߭ߎߦߋߟߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Vladivostok">
				<long>
					<generic>ߝ߭ߟߊߘߑߝ߭ߏߛߑߕߏߞ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝ߭ߟߊߘߑߝ߭ߏߛߑߕߏߞ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝ߭ߟߊߘߑߝ߭ߏߛߑߕߏߞ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Volgograd">
				<long>
					<generic>ߝ߭ߏߟߑߜ߭ߏߜ߭ߙߊߘ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߝ߭ߏߟߑߜ߭ߏߜ߭ߙߊߘ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߝ߭ߏߟߑߜ߭ߏߜ߭ߙߊߘ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Vostok">
				<long>
					<standard>ߝ߭ߐߛߑߕߐߞ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Wake">
				<long>
					<standard>ߥߊߞ ߕߌ߲ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Wallis">
				<long>
					<standard>ߥߊߟߌߛ ߣߌ߫ ߝߕߎߣߊ߫ ߕߎ߬ߡߊ߬ߘߊ</standard>
				</long>
			</metazone>
			<metazone type="Yakutsk">
				<long>
					<generic>ߦߊߞߎߕߑߛߞߌ߫ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߦߊߞߎߕߑߛߞߌ߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߦߊߞߎߕߑߛߞߌ߫ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Yekaterinburg">
				<long>
					<generic>ߦߋߞߊߕߋߙߌ߲ߓߎߙߜ߭ ߕߎ߬ߡߊ߬ߘߊ</generic>
					<standard>ߦߋߞߊߕߋߙߌ߲ߓߎߙߜ߭ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
					<daylight>ߦߋߞߊߕߋߙߌ߲ߓߎߙߜ߭ ߕߟߋ߬ߡߊ߬ ߕߎߡߘߊ</daylight>
				</long>
			</metazone>
			<metazone type="Yukon">
				<long>
					<standard>ߦߎߞߐ߲߫ ߕߎ߬ߡߘߊ߬ ߛߎߡߊ߲ߘߊ߲ߕߊ</standard>
				</long>
			</metazone>
		</timeZoneNames>
	</dates>
	<numbers>
		<defaultNumberingSystem>nkoo</defaultNumberingSystem>
		<otherNumberingSystems>
			<native>nkoo</native>
		</otherNumberingSystems>
		<symbols numberSystem="latn">
			<group>،</group>
		</symbols>
		<symbols numberSystem="nkoo">
			<group>،</group>
		</symbols>
		<currencies>
			<currency type="AED">
				<displayName>ߊߙߊߓߎߟߊ߫ ߡߊ߲߬ߛߊ߬ߙߋ߬ߠߊ ߟߊߘߍ߬ߣߍ߲ ߘߌ߬ߙߑߤߊߡ</displayName>
				<displayName count="other">ߊߙߊߓߎߟߊ߫ ߡߊ߲߬ߛߊ߬ߙߋ߬ߠߊ ߟߊߘߍ߬ߣߍ߲ ߘߌ߬ߙߑߤߊߡ</displayName>
				<symbol draft="contributed">ߊߐߘ</symbol>
			</currency>
			<currency type="AFN">
				<displayName>ߊߝߎߜ߭ߊߣߌߛߑߕߊ߲߫ ߊߝߑߜ߭ߊߣߌߛ</displayName>
				<displayName count="other">ߊߝߎߜ߭ߊߣߌߛߑߕߊ߲߫ ߊߝߑߜ߭ߊߣߌߛ</displayName>
				<symbol draft="contributed">ߊߝߊ</symbol>
			</currency>
			<currency type="ALL">
				<displayName>ߊߟߑߓߊߣߌ߫ ߟߍߞ</displayName>
				<displayName count="other">ߊߟߑߓߊߣߌ߫ ߟߍߞ</displayName>
				<symbol draft="contributed">ߊߟߟ</symbol>
			</currency>
			<currency type="AMD">
				<displayName>ߊߙߑߡߋߣߌ߫ ߘߌ߬ߙߑߤߊߡ</displayName>
				<displayName count="other">ߊߙߑߡߋߣߌ߫ ߘߌ߬ߙߑߤߊߡ</displayName>
				<symbol draft="contributed">ߊߡߘ</symbol>
			</currency>
			<currency type="ANG">
				<displayName>ߞߎߙߊߛߊߥߏ߫ ߊ߲ߕߌ߫ ߝߑߟߏߙߌ߲ߛ</displayName>
				<displayName count="other">ߞߎߙߊߛߊߥߏ߫ ߊ߲ߕߌ߫ ߝߑߟߏߙߌ߲ߛ</displayName>
				<symbol draft="contributed">ߊ߲ߕߝ</symbol>
			</currency>
			<currency type="AOA">
				<displayName>ߊ߲ߜ߭ߏߟߞߊ ߟߎ߬ ߟߊ߫ ߞߎߥߊ߲ߖ߭ߊ</displayName>
				<symbol draft="contributed">ߊ߲ߜ߭ߎ</symbol>
				<symbol alt="narrow" draft="contributed">ߞߖ߭</symbol>
			</currency>
			<currency type="AOK">
				<displayName>ߊ߲ߜ߭ߏߟߊ߫ ߞߎߥߊ߲ߖ߭ߊ ( ߁߉߇߇–߁߉߉߀ )</displayName>
			</currency>
			<currency type="AON">
				<displayName>ߊ߲ߜ߭ߏߟߊ߫ ߞߎߥߊߖ߭ߊ߫ ߞߎߘߊ ( ߁߉߉߀–߂߀߀߀ )</displayName>
				<symbol draft="contributed">ߊߜ߭ߞ</symbol>
			</currency>
			<currency type="AOR">
				<displayName>ߊ߲ߜ߭ߏߟߊ߫ ߞߎߥߊߖ߭ߊ ߝߊ߲߬ߞߊߘߏ߲߬ߣߍ߲ ( ߁߉߉߅–߁߉߉߉ )</displayName>
				<symbol draft="contributed">ߊߜ߭ߝ</symbol>
			</currency>
			<currency type="ARS">
				<displayName>ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߔߋߛߏ</displayName>
				<displayName count="other">ߊߙߑߖ߭ߊ߲ߕߌ߲߫ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߊߖ߭ߔ</symbol>
			</currency>
			<currency type="AUD">
				<displayName>ߐߛߑߕߙߊߟߌ߫ ߘߟߊ</displayName>
				<displayName count="other">ߐߛߑߕߙߊߟߌ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">$ߐ</symbol>
			</currency>
			<currency type="AWG">
				<displayName>ߊߙߎߓߊ߫ ߝߑߟߏߙߌ߲ߛ</displayName>
				<displayName count="other">ߊߙߎߓߊ߫ ߝߑߟߏߙߌ߲ߛ</displayName>
				<symbol draft="contributed">ߊߥߖ߭</symbol>
			</currency>
			<currency type="AZN">
				<displayName>ߊߖߍߙߑߓߊߦߌߖߊ߲߫ ߊߗ߭ߋߙߌ</displayName>
				<displayName count="other">ߊߖߍߙߑߓߊߦߌߖߊ߲߫ ߊߗ߭ߋߙߌ</displayName>
				<symbol draft="contributed">ߊߖߣ</symbol>
			</currency>
			<currency type="BAM">
				<displayName>ߓߐߛߑߣߌ߫ ߍߙߑߗ߭ߋߜ߭ߏߝ߭ߌߣ ߡߊߙߞ ߝߊ߬ߟߋ߲߬ߕߊ</displayName>
				<displayName count="other">ߓߐߛߑߣߌ߫ ߍߙߑߗ߭ߋߜ߭ߏߝ߭ߌߣ ߡߊߙߞ ߝߊ߬ߟߋ߲߬ߕߊ</displayName>
				<symbol draft="contributed">ߓߍߡ</symbol>
			</currency>
			<currency type="BBD">
				<displayName>ߓߊߙߑߓߊߘߐߛ ߘߟߊ</displayName>
				<displayName count="other">ߓߊߙߑߓߊߘߐߛ ߘߟߊ</displayName>
				<symbol draft="contributed">ߓߓߘ</symbol>
			</currency>
			<currency type="BDT">
				<displayName>ߓߊ߲ߜ߭ߑߟߊߘߍߛ ߕߞߊ</displayName>
				<displayName count="other">ߓߊ߲ߜ߭ߑߟߊߘߍߛ ߕߞߊ</displayName>
				<symbol draft="contributed">ߓߘߕ</symbol>
			</currency>
			<currency type="BGN">
				<displayName>ߓߎ߳ߟߑߜ߭ߊߙߌ߫ ߟߍߝ߭</displayName>
				<displayName count="other">ߓߎ߳ߟߑߜ߭ߊߙߌ߫ ߟߍߝ߭</displayName>
				<symbol draft="contributed">ߓߜ߭ߟ</symbol>
			</currency>
			<currency type="BHD">
				<displayName>ߓߤߊ߬ߙߊߦߌߣ ߘߌ߬ߣߊߙ</displayName>
				<displayName count="other">ߓߤߊ߬ߙߊߦߌߣ ߘߌ߬ߣߊߙ</displayName>
				<symbol draft="contributed">ߓߤߘ</symbol>
			</currency>
			<currency type="BIF">
				<displayName>ߓߎߙߎ߲ߘߌߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߓߙߝ</symbol>
			</currency>
			<currency type="BMD">
				<displayName>ߓߍߙߑߡߎߘߊ߫ ߘߟߊ</displayName>
				<displayName count="other">ߓߍߙߑߡߎߘߊ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">ߓߡߘ</symbol>
			</currency>
			<currency type="BND">
				<displayName>ߓߙߎߣߌ߫ ߘߟߊ</displayName>
				<displayName count="other">ߓߙߎߣߌ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">ߓߣߘ</symbol>
			</currency>
			<currency type="BOB">
				<displayName>ߓߏߟߝ߭ߌ߫ ߓߏߟߝ߭ߌߦߊߣߏ߬</displayName>
				<displayName count="other">ߓߏߟߝ߭ߌ߫ ߓߏߟߝ߭ߌߦߊߣߏ߬</displayName>
				<symbol draft="contributed">ߓߏߓ</symbol>
			</currency>
			<currency type="BRL">
				<displayName>ߓߙߋߖ߭ߌߟ ߙߋߦߊߟ</displayName>
				<displayName count="other">ߓߙߋߖ߭ߌߟ ߙߋߦߊߟ</displayName>
			</currency>
			<currency type="BSD">
				<displayName>ߓߤߊߡߊߛ ߘߟߊ</displayName>
				<displayName count="other">ߓߤߊߡߊߛ ߘߟߊ</displayName>
				<symbol draft="contributed">ߓߛߘ</symbol>
			</currency>
			<currency type="BTN">
				<displayName>ߓߎߕߊ߲߫ ߒߜ߭ߎߟߑߕߙߎߡ</displayName>
				<displayName count="other">ߓߎߕߊ߲߫ ߒߜ߭ߎߟߑߕߙߎߡ</displayName>
				<symbol draft="contributed">ߓߕߒ</symbol>
			</currency>
			<currency type="BWP">
				<displayName>ߓߐߛߎߥߣߊߞߊ ߟߎ߬ ߟߊ߫ ߔߎߟߊ</displayName>
				<symbol draft="contributed">ߓߥߔ</symbol>
				<symbol alt="narrow" draft="contributed">ߔ</symbol>
			</currency>
			<currency type="BYN">
				<displayName>ߓߌߟߏߙߌߛ ߙߓߎߟ</displayName>
				<displayName count="other">ߓߌߟߏߙߌߛ ߙߓߎߟ</displayName>
				<symbol draft="contributed">ߓߌߙ</symbol>
			</currency>
			<currency type="BZD">
				<displayName>ߓߙߋߖ߭ߌߟ ߘߟߊ</displayName>
				<displayName count="other">ߓߙߋߖ߭ߌߟ ߘߟߊ</displayName>
			</currency>
			<currency type="CDF">
				<displayName>ߞߏ߲߬ߜ߭ߏ߬ߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߞߝ</symbol>
			</currency>
			<currency type="CHF">
				<displayName>ߛߎߥߌߛ ߝߊߙߊ߲</displayName>
				<displayName count="other">ߛߎߥߌߛ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߛߥߝ</symbol>
			</currency>
			<currency type="CLP">
				<displayName>ߛ߭ߟߌ߫ ߔߋߛߏ</displayName>
				<displayName count="other">ߛ߭ߟߌ߫ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߛߟߔ</symbol>
			</currency>
			<currency type="CNH">
				<displayName>ߛߌߣ ߦߎߥߊߣ (ߝߊ߲߬ߕߙߊ ߖߌߘߊ)</displayName>
				<displayName count="other">ߛߌߣ ߦߎߥߊߣ (ߝߊ߲߬ߕߙߊ ߖߌߘߊ)</displayName>
				<symbol draft="contributed">ߛߦߤ</symbol>
			</currency>
			<currency type="CNY">
				<displayName>ߦߎߥߊߣ ߙߊ߲ߡߌ߲ߓߌ߫</displayName>
				<displayName count="other">ߦߎߥߊߣ ߙߊ߲ߡߌ߲ߓߌ߫</displayName>
				<symbol draft="contributed">ߛߣߦ</symbol>
			</currency>
			<currency type="COP">
				<displayName>ߞߐߟߐ߲ߓߌ߫ ߔߋߛߏ</displayName>
				<displayName count="other">ߞߐߟߐ߲ߓߌ߫ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߞߐߔ</symbol>
			</currency>
			<currency type="CRC">
				<displayName>ߞߐߛߑߕߊߙߌߞߊ߫ ߞߐߟߐߣ</displayName>
				<displayName count="other">ߞߐߛߑߕߊߙߌߞߊ߫ ߞߐߟߐߣ</displayName>
				<symbol draft="contributed">ߞߙߞ</symbol>
			</currency>
			<currency type="CUC">
				<displayName>ߞߎ߳ߓߊ߫ ߔߋߛߏ߫ ߝߊ߬ߟߋ߲߬ߕߊ</displayName>
				<displayName count="other">ߞߎ߳ߓߊ߫ ߔߋߛߏ߫ ߝߊ߬ߟߋ߲߬ߕߊ</displayName>
				<symbol draft="contributed">ߞߎ߳ߞ</symbol>
			</currency>
			<currency type="CUP">
				<displayName>ߞߎ߳ߓߊ߫ ߔߋߛߏ߫߫</displayName>
				<displayName count="other">ߞߎ߳ߓߊ߫ ߔߋߛߏ߫߫</displayName>
				<symbol draft="contributed">ߞߎ߳ߔ</symbol>
			</currency>
			<currency type="CVE">
				<displayName>ߜߙߋߞߎ߲߫ ߝߙߌߛߌߞߊ ߟߎ߬ ߍߛߑߞߎߘߐߛ</displayName>
				<symbol draft="contributed">ߍߛߞ</symbol>
			</currency>
			<currency type="CZK">
				<displayName>ߗߋߞߏߛߟߏߝ߭ߊߞߌ߫ ߞߎߙߐߣ</displayName>
				<displayName count="other">ߗߋߞߏߛߟߏߝ߭ߊߞߌ߫ ߞߎߙߐߣ</displayName>
				<symbol draft="contributed">ߗߞߞ</symbol>
			</currency>
			<currency type="DJF">
				<displayName>ߖߌߓߎߕߌߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߖߓߝ</symbol>
			</currency>
			<currency type="DKK">
				<displayName>ߘߊߣߌߡߊߙߞ ߞߎߙߐߣ</displayName>
				<displayName count="other">ߘߊߣߌߡߊߙߞ ߞߎߙߐߣ</displayName>
				<symbol draft="contributed">ߘߞߞ</symbol>
			</currency>
			<currency type="DOP">
				<displayName>ߘߏߡߣߌߞ ߞߊ߲ߓߍ߲ ߔߋߛߏ</displayName>
				<displayName count="other">ߘߏߡߣߌߞ ߞߊ߲ߓߍ߲ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߘߏߔ</symbol>
			</currency>
			<currency type="DZD">
				<displayName>ߊߟߌߖ߭ߋߙߌߞߊ ߟߎ߬ ߟߊ߫ ߘߌ߬ߣߊ߯ߙߌ</displayName>
				<symbol draft="contributed">ߊߟߘ</symbol>
			</currency>
			<currency type="EGP">
				<displayName>ߡߌߛߌߙߊ߲ߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߡߛߔ</symbol>
			</currency>
			<currency type="ERN">
				<displayName>ߋߙߌߕߙߋߞߊ ߟߎ߬ ߟߊ߫ ߣߊߝߑߞߊ</displayName>
				<symbol draft="contributed">ߋߙߝ</symbol>
			</currency>
			<currency type="ETB">
				<displayName>ߋߗߏߔߌߞߊ ߟߎ߬ ߟߊ߫ ߓߌߙߑߛ</displayName>
				<symbol draft="contributed">ߋߗߓ</symbol>
			</currency>
			<currency type="EUR">
				<displayName>ߋߙߏ</displayName>
				<displayName count="other">ߋߙߏ</displayName>
			</currency>
			<currency type="FJD">
				<displayName>ߝߖߌ߫ ߘߟߊ</displayName>
				<displayName count="other">ߝߖߌ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">$ ߝߖ</symbol>
			</currency>
			<currency type="FKP">
				<displayName>ߝߊߟߞߑߟߊ߲ߘ ߌߛߑߟߊ߲ߘ ߔߐߣߌ߬</displayName>
				<displayName count="other">ߝߊߟߞߑߟߊ߲ߘ ߌߛߑߟߊ߲ߘ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߝߞߔ</symbol>
			</currency>
			<currency type="GBP">
				<displayName>ߡߊ߬ߛߊ߬ߟߊ߫-ߘߍ߬ߣߍ߲ ߔߐߣߌ߬</displayName>
				<displayName count="other">ߡߊ߬ߛߊ߬ߟߊ߫-ߘߍ߬ߣߍ߲ ߔߐߣߌ߬</displayName>
			</currency>
			<currency type="GEL">
				<displayName>ߖ߭ߐߙߑߖߌ߫ ߟߊߙߌ</displayName>
				<displayName count="other">ߖ߭ߐߙߑߖߌ߫ ߟߊߙߌ</displayName>
				<symbol draft="contributed">ߖ߭ߐߟ</symbol>
			</currency>
			<currency type="GHC">
				<displayName>ߛߘߌ</displayName>
				<displayName count="other">ߜ߭ߊ߯ߣߊ߫ ߛߘߌ ( ߁߉߆߇–߂߀߀߇ )</displayName>
			</currency>
			<currency type="GHS">
				<displayName>ߜ߭ߊ߯ߣߊ߫ ߛߘߌ</displayName>
				<displayName count="other">ߜ߭ߊ߯ߣߞߊ ߟߎ߬ ߛߘߌ</displayName>
				<symbol draft="contributed">ߜ߭ߛߘ</symbol>
			</currency>
			<currency type="GIP">
				<displayName>ߖ߭ߌߓߑߙߊߟߑߕߊ߫ ߔߐߣߌ߬</displayName>
				<displayName count="other">ߖ߭ߌߓߑߙߊߟߑߕߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߖ߭ߓߔ£</symbol>
			</currency>
			<currency type="GMD">
				<displayName>ߜ߭ߊ߲ߓߌߞߊ ߟߎ߬ ߟߊ߫ ߘߟߊߛߌ߫</displayName>
				<symbol draft="contributed">ߜ߭ߓߘ</symbol>
			</currency>
			<currency type="GNF">
				<displayName>ߖߌ߬ߣߍ߬ߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">߿</symbol>
				<symbol alt="narrow" draft="contributed">߿</symbol>
			</currency>
			<currency type="GNS">
				<displayName>ߖߌ߬ߣߍ߬ߞߊ ߟߎ߬ ߟߊ߫ ߛߟߌ</displayName>
				<symbol draft="contributed">ߖߛ߾</symbol>
			</currency>
			<currency type="GQE">
				<displayName>ߕߍߡߊߓߊ߲߮ ߖߌ߬ߣߍ߬ߞߊ ߟߎ߬ ߟߊ߫ ߋߞߥߋߟߋ</displayName>
				<symbol draft="contributed">ߕߖߋ</symbol>
			</currency>
			<currency type="GTQ">
				<displayName>ߜ߭ߎߥߊߕߋߡߟߊ߫ ߞߋߕߑߗ߭ߊߟ</displayName>
				<displayName count="other">ߜ߭ߎߥߊߕߋߡߟߊ߫ ߞߋߕߑߗ߭ߊߟ</displayName>
				<symbol draft="contributed">ߜ߭ߕߞ</symbol>
			</currency>
			<currency type="GWE">
				<displayName>ߖߌߣߍ߫ ߓߌߛߊߥߏߞߊ ߟߎ߬ ߟߊ߫ ߍߛߑߞߎߘߐߛ</displayName>
				<symbol draft="contributed">ߖߓߍ</symbol>
			</currency>
			<currency type="GWP">
				<displayName>ߖߌߣߍ߫ ߓߌߛߊߥߏߞߊ ߟߎ߬ ߟߊ߫ ߔߋߖ߭ߏ</displayName>
				<symbol draft="contributed">ߖߓߔ</symbol>
			</currency>
			<currency type="GYD">
				<displayName>ߜ߭ߎ߳ߦߊߣ ߘߟߊ</displayName>
				<displayName count="other">ߜ߭ߎ߳ߦߊߣ ߘߟߊ</displayName>
				<symbol draft="contributed">ߜ߭ߎ߳ߘ</symbol>
			</currency>
			<currency type="HKD">
				<displayName>ߤߐ߲ߞߐ߲߫ ߘߟߊ</displayName>
				<displayName count="other">ߤߐ߲ߞߐ߲߫ ߘߟߊ</displayName>
				<symbol draft="contributed">ߤߞߘ</symbol>
			</currency>
			<currency type="HNL">
				<displayName>ߤߐ߲ߘߎߙߊ߫ ߟߋ߲ߔߌߙߊ</displayName>
				<displayName count="other">ߤߐ߲ߘߎߙߊ߫ ߟߋ߲ߔߌߙߊ</displayName>
				<symbol draft="contributed">ߤߘߟ</symbol>
			</currency>
			<currency type="HRK">
				<displayName>ߞߙߏߥߊߛߌ߫ ߞߎߣߊ߬</displayName>
				<displayName count="other">ߞߙߏߥߊߛߌ߫ ߞߎߣߊ߬</displayName>
				<symbol draft="contributed">ߞߛߞ</symbol>
			</currency>
			<currency type="HTG">
				<displayName>ߤߊߦߕߌ߫ ߜ߭ߎߙߑߘ</displayName>
				<displayName count="other">ߤߊߦߕߌ߫ ߜ߭ߎߙߑߘ</displayName>
				<symbol draft="contributed">ߤߕߜ߭</symbol>
			</currency>
			<currency type="HUF">
				<displayName>ߢߐ߲ߜ߭ߙߌ߫ ߝߏߙߍ߲ߕ</displayName>
				<displayName count="other">ߢߐ߲ߜ߭ߙߌ߫ ߝߏߙߍ߲ߕ</displayName>
				<symbol draft="contributed">ߤߜ߭ߝ</symbol>
			</currency>
			<currency type="IDR">
				<displayName>ߍ߲ߘߣߏߛߌ߫ ߙߎߔߌ</displayName>
				<displayName count="other">ߍ߲ߘߣߏߛߌ߫ ߙߎߔߌ</displayName>
				<symbol draft="contributed">ߍ߲ߘߙ</symbol>
			</currency>
			<currency type="ILS">
				<displayName>ߌߛߑߙߊߍߟ ߛߌߞߍߟ ߞߎߘߊ</displayName>
				<displayName count="other">ߌߛߑߙߊߍߟ ߛߌߞߍߟ ߞߎߘߊ</displayName>
			</currency>
			<currency type="INR">
				<displayName>ߤߌ߲ߘߎ߬ ߙߎߔߌ</displayName>
				<displayName count="other">ߤߌ߲ߘߎ߬ ߙߎߔߌ</displayName>
			</currency>
			<currency type="IQD">
				<displayName>ߌߙߊߞߌ߬ ߘߌ߬ߣߊߙ</displayName>
				<displayName count="other">ߌߙߊߞߌ߬ ߘߌ߬ߣߊߙ</displayName>
				<symbol draft="contributed">ߌߞߘ</symbol>
			</currency>
			<currency type="IRR">
				<displayName>ߌߙߊ߲߫ ߙߌ߬ߦߊߟ</displayName>
				<displayName count="other">ߌߙߊ߲߫ ߙߌ߬ߦߊߟ</displayName>
				<symbol draft="contributed">ߌߙߙ</symbol>
			</currency>
			<currency type="ISK">
				<displayName>ߌߛߑߟߊ߲ߘ ߞߎߙߐߣ</displayName>
				<displayName count="other">ߌߛߑߟߊ߲ߘ ߞߎߙߐߣ</displayName>
				<symbol draft="contributed">ߌߛߞ</symbol>
			</currency>
			<currency type="JMD">
				<displayName>ߖߡߊߦߌߞ ߘߟߊ</displayName>
				<displayName count="other">ߖߡߊߦߌߞ ߘߟߊ</displayName>
				<symbol draft="contributed">ߖߡߘ</symbol>
			</currency>
			<currency type="JOD">
				<displayName>ߖߐߙߑߘߊߣߌ߫ ߘߌ߬ߣߊߙ</displayName>
				<displayName count="other">ߖߐߙߑߘߊߣߌ߫ ߘߌ߬ߣߊߙ</displayName>
				<symbol draft="contributed">ߖߐߘ</symbol>
			</currency>
			<currency type="JPY">
				<displayName>ߣߌߔߐ߲߫ ߦߍߣ</displayName>
				<displayName count="other">ߣߌߔߐ߲߫ ߦߍߣ</displayName>
				<symbol draft="contributed">ߗ߭ߔߦ</symbol>
			</currency>
			<currency type="KES">
				<displayName>ߝߋߣߌߦߞߊ ߟߎ߬ ߟߊ߫ ߛߌߟߌ߲ߜ߭</displayName>
				<symbol draft="contributed">ߞߋߛ</symbol>
			</currency>
			<currency type="KGS">
				<displayName>ߞߌߙߜ߭ߌߛߑߕߊ߲߫ ߛߐߡ</displayName>
				<displayName count="other">ߞߌߙߜ߭ߌߛߑߕߊ߲߫ ߛߐߡ</displayName>
				<symbol draft="contributed">ߞߜ߭ߛ</symbol>
			</currency>
			<currency type="KHR">
				<displayName>ߞߊ߲ߓߐߘߑߖ ߙߌߦߍߟ</displayName>
				<displayName count="other">ߞߊ߲ߓߐߘߑߖ ߙߌߦߍߟ</displayName>
				<symbol draft="contributed">ߞߓߙ</symbol>
			</currency>
			<currency type="KMF">
				<displayName>ߞߐߡ߲߯ߙߌߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߞߡߝ</symbol>
				<symbol alt="narrow" draft="contributed">ߝߛ</symbol>
			</currency>
			<currency type="KPW">
				<displayName>ߞߐ߬ߘߎ߮-ߞߏߙߋ߫ ߥߐߣ</displayName>
				<displayName count="other">ߞߐ߬ߘߎ߮-ߞߏߙߋ߫ ߥߐߣ</displayName>
				<symbol draft="contributed">ߞߞߥ</symbol>
			</currency>
			<currency type="KRW">
				<displayName>ߥߙߏ߬ߘߎ߮-ߞߏߙߋ߫ ߥߐߣ</displayName>
				<displayName count="other">ߥߙߏ߬ߘߎ߮-ߞߏߙߋ߫ ߥߐߣ</displayName>
			</currency>
			<currency type="KWD">
				<displayName>ߞߎ߬ߥߍߕ ߘߌ߬ߣߊߙ</displayName>
				<displayName count="other">ߞߎ߬ߥߍߕ ߘߌ߬ߣߊߙ</displayName>
				<symbol draft="contributed">ߞߥߘ</symbol>
			</currency>
			<currency type="KYD">
				<displayName>ߞߊߦߌߡߊ߲߫ ߌߛߑߟߊ߲ߘ ߘߟߊ</displayName>
				<displayName count="other">ߞߊߦߌߡߊ߲߫ ߌߛߑߟߊ߲ߘ ߘߟߊ</displayName>
				<symbol draft="contributed">ߞߌߘ</symbol>
			</currency>
			<currency type="KZT">
				<displayName>ߞߗ߭ߊߞߌߛߑߕߊ߲߫ ߕߊ߲ߖ߭</displayName>
				<displayName count="other">ߞߗ߭ߊߞߌߛߑߕߊ߲߫ ߕߊ߲ߖ߭</displayName>
				<symbol draft="contributed">ߞߗ߭ߕ</symbol>
			</currency>
			<currency type="LAK">
				<displayName>ߟߊߏߕߌ߫ ߞߌߔ</displayName>
				<displayName count="other">ߟߊߏߕߌ߫ ߞߌߔ</displayName>
				<symbol draft="contributed">ߟߊߞ</symbol>
			</currency>
			<currency type="LBP">
				<displayName>ߟߌߓߊ߲߫ ߔߐߣߌ߬</displayName>
				<displayName count="other">ߟߌߓߊ߲߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߟߓ£</symbol>
			</currency>
			<currency type="LKR">
				<displayName>ߛߙߌ߫ ߟߊ߲ߞߊ߫ ߙߎߔߌ</displayName>
				<displayName count="other">ߛߙߌ߫ ߟߊ߲ߞߊ߫ ߙߎߔߌ</displayName>
				<symbol draft="contributed">ߟߞߙ</symbol>
			</currency>
			<currency type="LRD">
				<displayName>ߟߌߓߋߙߌߦߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊߙ</displayName>
				<symbol draft="contributed">ߟ߾</symbol>
			</currency>
			<currency type="LSL">
				<displayName>ߟߋߛߕߏߞߊ ߟߎ߬ ߟߊ߫ ߟߏߕߌ</displayName>
				<symbol draft="contributed">ߟߛߟ</symbol>
			</currency>
			<currency type="LYD">
				<displayName>ߟߓߌ߫ ߘߌ߬ߣߊ߯ߙ</displayName>
				<displayName count="other">ߟߓߌߞߊ ߟߎ߬ ߟߊ߫ ߘߌ߬ߣߊ߯ߙ</displayName>
				<symbol draft="contributed">ߟߓߘ</symbol>
			</currency>
			<currency type="MAD">
				<displayName>ߡߊ߬ߙߐߞߎ߬ ߘߌ߬ߙߑߤߊߡ</displayName>
				<displayName count="other">ߡߊ߬ߙߐ߬ߞߎ߬ߞߊ ߟߎ߬ ߟߊ߫ ߘߌ߬ߙߑߤߊߡ</displayName>
				<symbol draft="contributed">ߡߘߤ</symbol>
			</currency>
			<currency type="MAF">
				<displayName>ߡߊ߬ߙߐ߬ߞߎߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߡߙߝ</symbol>
			</currency>
			<currency type="MDL">
				<displayName>ߝߐߟߑߘߊߝ߭ߌ߫ ߟߋ߳</displayName>
				<displayName count="other">ߝߐߟߑߘߊߝ߭ߌ߫ ߟߋ߳</displayName>
				<symbol draft="contributed">ߡߘߟ</symbol>
			</currency>
			<currency type="MGA">
				<displayName>ߡߘߊߜ߭ߊߛߑߞߊ߯ߙߌߞߊ ߟߎ߬ ߟߊ߫ ߊߙߌߦߊߙߌ</displayName>
				<symbol draft="contributed">ߡߘߙ</symbol>
				<symbol alt="narrow" draft="contributed">ߊߙ</symbol>
			</currency>
			<currency type="MGF">
				<displayName>ߡߘߊߜ߭ߊߑߞߊ߯ߙߌߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߡߘߝ</symbol>
			</currency>
			<currency type="MKD">
				<displayName>ߡߊߛߋߘߏߣߌ߫ ߘߋߣߊߙ</displayName>
				<displayName count="other">ߡߊߛߋߘߏߣߌ߫ ߘߋߣߊߙ</displayName>
				<symbol draft="contributed">ߡߞߘ</symbol>
			</currency>
			<currency type="MLF">
				<displayName>ߡߊߟߌߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߡߝ</symbol>
			</currency>
			<currency type="MMK">
				<displayName>ߡߌߦߊ߲ߡߊߙ ߞߌߦߊߕ</displayName>
				<displayName count="other">ߡߌߦߊ߲ߡߊߙ ߞߌߦߊߕ</displayName>
				<symbol draft="contributed">ߡߡߞ</symbol>
			</currency>
			<currency type="MNT">
				<displayName>ߡߐ߲ߜ߭ߐߟߌ߫ ߕߎߜ߭ߙߌߞ</displayName>
				<displayName count="other">ߡߐ߲ߜ߭ߐߟߌ߫ ߕߎߜ߭ߙߌߞ</displayName>
				<symbol draft="contributed">ߡߣߕ</symbol>
			</currency>
			<currency type="MOP">
				<displayName>ߡߞߊߥߏ߫ ߔߕߊߞߊ߫</displayName>
				<displayName count="other">ߡߞߊߥߏ߫ ߔߕߊߞߊ߫</displayName>
				<symbol draft="contributed">ߡߏߔ</symbol>
			</currency>
			<currency type="MRO">
				<displayName>ߡߏߙߌߕߊߣߌߞߊ ߟߎ߬ ߟߊ߫ ߎ߬ߜ߭ߌߦߊ ( ߁߉߇߃–߂߀߁߇ )</displayName>
				<symbol draft="contributed">ߡߙߏ</symbol>
			</currency>
			<currency type="MRU">
				<displayName>ߡߏߙߌߕߊߣߌߞߊ ߟߎ߬ ߟߊ߫ ߎ߬ߜ߭ߌߦߊ</displayName>
				<symbol draft="contributed">ߡߎߜ߭</symbol>
			</currency>
			<currency type="MUR">
				<displayName>ߡߏߙߛߌߞߊ ߟߎ߬ ߟߊ߫ ߙߔߎ</displayName>
				<symbol draft="contributed">ߡߙߔ</symbol>
				<symbol alt="narrow" draft="contributed">ߙߛ</symbol>
			</currency>
			<currency type="MVR">
				<displayName>ߡߊߟߑߘߝ߭ߌ߫ ߙߎߝߌߦߊ</displayName>
				<displayName count="other">ߡߊߟߑߘߝ߭ߌ߫ ߙߎߝߌߦߊ</displayName>
				<symbol draft="contributed">ߡߝ߭ߙ</symbol>
			</currency>
			<currency type="MWK">
				<displayName>ߡߟߊߥߌߞߊ ߟߎ߬ ߟߊ߫ ߞߎߥߛߊ</displayName>
				<symbol draft="contributed">ߡߟߞ</symbol>
			</currency>
			<currency type="MXN">
				<displayName>ߡߍߞߑߛߌߞ ߔߋߛߏ</displayName>
				<displayName count="other">ߡߍߞߑߛߌߞ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߡߞ$</symbol>
			</currency>
			<currency type="MYR">
				<displayName>ߡߊߟߍߘߎ߯ ߙߌ߲ߖ߭ߌ</displayName>
				<displayName count="other">ߡߊߟߍߘߎ߯ ߙߌ߲ߖ߭ߌ</displayName>
				<symbol draft="contributed">ߡߦߙ</symbol>
			</currency>
			<currency type="MZE">
				<displayName>ߡߏߖ߭ߊ߲ߓߞߌߞߊ ߟߎ߬ ߟߊ߫ ߍߛߑߞߎߘߏߛ</displayName>
				<symbol draft="contributed">ߡߖ߭ߋ</symbol>
			</currency>
			<currency type="MZM">
				<displayName>ߡߏߖ߭ߊ߲ߓߞߌߞߊ ߟߎ߬ ߟߊ߫ ߡߋߕߌߞ ( ߁߉߈߀–߂߀߀߆ )</displayName>
				<symbol draft="contributed">ߡߖߡ</symbol>
			</currency>
			<currency type="MZN">
				<displayName>ߡߏߖ߭ߊ߲ߓߞߌߞߊ ߟߎ߬ ߟߊ߫ ߡߋߕߌߞߊߟ</displayName>
				<symbol draft="contributed">ߡߖ߭ߡ</symbol>
			</currency>
			<currency type="NAD">
				<displayName>ߣߊߡߌ߲ߓߌߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊ߯ߙ</displayName>
				<symbol draft="contributed">ߣߡߘ</symbol>
				<symbol alt="narrow" draft="contributed">ߛ</symbol>
			</currency>
			<currency type="NGN">
				<displayName>ߖߋ߬ߟߌ߬ߓߊ߬ߞߊ ߟߎ߬ ߟߊ߫ ߣߍߙߊ</displayName>
				<symbol draft="contributed">ߖߣ</symbol>
			</currency>
			<currency type="NIO">
				<displayName>ߣߌߞߙߊߜ߭ߎߥߊ߫ ߞߐߙߑߘߏߓߊ߫ ߏߙߏ߫</displayName>
				<displayName count="other">ߣߌߞߙߊߜ߭ߎߥߊ߫ ߞߐߙߑߘߏߓߊ߫ ߏߙߏ߫</displayName>
				<symbol draft="contributed">ߣߌߏ</symbol>
			</currency>
			<currency type="NOK">
				<displayName>ߣߐߙߑߝ߭ߍߛ ߞߎߙߐߣ</displayName>
				<displayName count="other">ߣߐߙߑߝ߭ߍߛ ߞߎߙߐߣ</displayName>
				<symbol draft="contributed">ߣߐߞ</symbol>
			</currency>
			<currency type="NPR">
				<displayName>ߣߋߔߊߟ ߙߎߔߌ</displayName>
				<displayName count="other">ߣߋߔߊߟ ߙߎߔߌ</displayName>
				<symbol draft="contributed">ߣߔߙ</symbol>
			</currency>
			<currency type="NZD">
				<displayName>ߣߌߦߎߖ߭ߌߟߊ߲ߘߌ߫ ߘߟߊ</displayName>
				<displayName count="other">ߣߌߦߎߖ߭ߌߟߊ߲ߘߌ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">$ߣߖ߭</symbol>
			</currency>
			<currency type="OMR">
				<displayName>ߏߡߊߣ ߙߌ߬ߦߊߟ</displayName>
				<displayName count="other">ߏߡߊߣ ߙߌ߬ߦߊߟ</displayName>
				<symbol draft="contributed">ߏߡߙ</symbol>
			</currency>
			<currency type="PAB">
				<displayName>ߔߣߊߡߊ߫ ߓߊߟߑߓߏߥߊ߫</displayName>
				<displayName count="other">ߔߣߊߡߊ߫ ߓߊߟߑߓߏߥߊ߫</displayName>
				<symbol draft="contributed">ߔߊߓ</symbol>
			</currency>
			<currency type="PEN">
				<displayName>ߔߋߙߎ߫ ߛߐߟ</displayName>
				<displayName count="other">ߔߋߙߎ߫ ߛߐߟ</displayName>
				<symbol draft="contributed">ߔߋߛ</symbol>
			</currency>
			<currency type="PGK">
				<displayName>ߔߊߔߎߥߊ߫ ߖߌ߬ߣߍ߬ ߞߎߘߊ߫ ߞߌߣߊ</displayName>
				<displayName count="other">ߔߊߔߎߥߊ߫ ߖߌ߬ߣߍ߬ ߞߎߘߊ߫ ߞߌߣߊ</displayName>
				<symbol draft="contributed">ߔߖߞ</symbol>
			</currency>
			<currency type="PHP">
				<displayName>ߝߟߌߔߌߣ ߔߋߛߏ</displayName>
				<displayName count="other">ߝߟߌߔߌߣ ߔߋߛߏ</displayName>
			</currency>
			<currency type="PKR">
				<displayName>ߔߊߞߌߛߑߕߊ߲߫ ߙߎߔߌ</displayName>
				<displayName count="other">ߔߊߞߌߛߑߕߊ߲߫ ߙߎߔߌ</displayName>
				<symbol draft="contributed">ߔߞߙ</symbol>
			</currency>
			<currency type="PLN">
				<displayName>ߔߏߟߐߢ ߗ߭ߑߟߏߕߌ߫</displayName>
				<displayName count="other">ߔߏߟߐߢ ߗ߭ߑߟߏߕߌ߫</displayName>
				<symbol draft="contributed">ߔߟߗ߭</symbol>
			</currency>
			<currency type="PYG">
				<displayName>ߔߙߊߜ߭ߏߦߋ߫ ߜ߭ߎߙߊߣߊߛ</displayName>
				<displayName count="other">ߔߙߊߜ߭ߏߦߋ߫ ߜ߭ߎߙߊߣߊߛ</displayName>
				<symbol draft="contributed">ߔߙߜ߭</symbol>
			</currency>
			<currency type="QAR">
				<displayName>ߞߕߊߙ ߙߌ߬ߦߊߟ</displayName>
				<displayName count="other">ߞߕߊߙ ߙߌ߬ߦߊߟ</displayName>
				<symbol draft="contributed">ߞߊߙ</symbol>
			</currency>
			<currency type="RHD">
				<displayName>ߖ߭ߌ߲ߓߊߓߏߦߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊ߯ߙ</displayName>
				<symbol draft="contributed">ߖ߭ߓߘ</symbol>
			</currency>
			<currency type="RON">
				<displayName>ߙߎߡߊߣߌ߫ ߟߋ߳</displayName>
				<displayName count="other">ߙߎߡߊߣߌ߫ ߟߋ߳</displayName>
				<symbol draft="contributed">ߙߎߟ</symbol>
			</currency>
			<currency type="RSD">
				<displayName>ߛߍߙߑߓߌ߫ ߘߋߣߊߙ</displayName>
				<displayName count="other">ߛߍߙߑߓߌ߫ ߘߋߣߊߙ</displayName>
				<symbol draft="contributed">ߙߛߘ</symbol>
			</currency>
			<currency type="RUB">
				<displayName>ߌ߬ߙߌ߬ߛߌ߫ ߙߎߓߎߟ</displayName>
				<displayName count="other">ߌ߬ߙߌ߬ߛߌ߫ ߙߎߓߎߟ</displayName>
				<symbol draft="contributed">ߌߎߙ</symbol>
			</currency>
			<currency type="RWF">
				<displayName>ߙߎߥߊ߲ߘߞߊ ߟߎ߬ ߟߊ߫ ߝߊߙߊ߲</displayName>
				<symbol draft="contributed">ߙߥߝ</symbol>
				<symbol alt="narrow" draft="contributed">ߝߙ</symbol>
			</currency>
			<currency type="SAR">
				<displayName>ߛߎ߰ߘߎ߬ߟߊ߫ ߙߌ߬ߦߊߟ</displayName>
				<displayName count="other">ߛߎ߰ߘߎ߬ߟߊ߫ ߙߌ߬ߦߊߟ</displayName>
				<symbol draft="contributed">ߛߊߙ</symbol>
			</currency>
			<currency type="SBD">
				<displayName>ߛߟߏ߬ߡߣߊ߬ ߕߌ߲ ߠߎ߬ ߘߟߊ</displayName>
				<displayName count="other">ߛߟߏ߬ߡߣߊ߬ ߕߌ߲ ߠߎ߬ ߘߟߊ</displayName>
				<symbol draft="contributed">ߛߓߘ</symbol>
			</currency>
			<currency type="SCR">
				<displayName>ߛߋߦߌߛߍߟߌߞߊ ߟߎ߬ ߟߊ߫ ߙߎߔߌ</displayName>
				<symbol draft="contributed">ߛߛߥ</symbol>
			</currency>
			<currency type="SDD">
				<displayName>ߛߎ߬ߘߊ߲߬ߞߊ ߟߎ߬ ߘߌ߬ߣߊ߯ߙ ( ߁߉߉߂–߂߀߀߇ )</displayName>
				<symbol draft="contributed">ߛߘߘ</symbol>
			</currency>
			<currency type="SDG">
				<displayName>ߛߎߘߊ߲ߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߛߘߜ߭</symbol>
			</currency>
			<currency type="SDP">
				<displayName>ߛߎ߬ߘ߲ߊ߬ߞߊ ߟߊ߫ ߔߐߣߌ߬ ( ߁߉߅߆–߂߀߀߇ )</displayName>
				<symbol draft="contributed">ߛߘߔ</symbol>
			</currency>
			<currency type="SEK">
				<displayName>ߛߎߥߍߘ ߞߎߙߐߣ</displayName>
				<displayName count="other">ߛߎߥߍߘ ߞߎߙߐߣ</displayName>
				<symbol draft="contributed">ߛߥߞ</symbol>
			</currency>
			<currency type="SGD">
				<displayName>ߛߍ߲ߜ߭ߊߔߎߙ ߘߟߊ</displayName>
				<displayName count="other">ߛߍ߲ߜ߭ߊߔߎߙ ߘߟߊ</displayName>
				<symbol draft="contributed">ߛߜ߭ߘ</symbol>
			</currency>
			<currency type="SHP">
				<displayName>ߛߍ߲ߕ ߤߌߟߋߣߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߛߤߔ</symbol>
			</currency>
			<currency type="SLE">
				<displayName>ߛߙߊ߬ߟߏ߲߬ߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߛߙߔ</symbol>
			</currency>
			<currency type="SLL">
				<displayName>ߛߙߊ߬ߟߏ߲߬ߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬ - 1964-2022</displayName>
				<symbol draft="contributed">ߛߟߟ</symbol>
			</currency>
			<currency type="SOS">
				<displayName>ߛߏߡߊߟߌߞߊ ߟߎ߬ ߟߊ߫ ߛߌߟߌ߲ߜ߭</displayName>
				<symbol draft="contributed">ߛߡߛ</symbol>
			</currency>
			<currency type="SRD">
				<displayName>ߛߎߙߌߣߊߡߍߛ ߘߟߊ</displayName>
				<displayName count="other">ߛߎߙߌߣߊߡߍߛ ߘߟߊ</displayName>
				<symbol draft="contributed">ߛߎߘ</symbol>
			</currency>
			<currency type="SSP">
				<displayName>ߛߎ߬ߘߊ߲߬ߞߊ ߟߎ߬ ߟߊ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߛߛߔ</symbol>
			</currency>
			<currency type="STD">
				<displayName>ߛߊߏߕߏߡߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߓߙߊߛ ( ߁߉߇߇– ߂߀߁߇ )</displayName>
				<symbol draft="contributed">ߛߕߘ</symbol>
			</currency>
			<currency type="STN">
				<displayName>ߛߊߏߕߏߡߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߓߙߊߛ</displayName>
				<symbol draft="contributed">ߛߔߘ</symbol>
				<symbol alt="narrow" draft="contributed">ߛߓ</symbol>
			</currency>
			<currency type="SYP">
				<displayName>ߛߌ߯ߙߌ߫ ߔߐߣߌ߬</displayName>
				<displayName count="other">ߛߌ߯ߙߌ߫ ߔߐߣߌ߬</displayName>
				<symbol draft="contributed">ߛߌߔ</symbol>
			</currency>
			<currency type="SZL">
				<displayName>ߛߑߥߊߕߣߞߊ ߟߎ߬ ߟߌߟߊ߲ߖ߭ߋߣߌߛ</displayName>
				<symbol draft="contributed">ߛߖ߭ߟ</symbol>
			</currency>
			<currency type="THB">
				<displayName>ߕߊߦߌߘߎ߯ ߓߊߘ</displayName>
				<displayName count="other">ߕߊߦߌߘߎ߯ ߓߊߘ</displayName>
				<symbol draft="contributed">ߕߘߓ</symbol>
			</currency>
			<currency type="TJS">
				<displayName>ߕߊߖߞߌߛߑߕߊ߲߫ ߛߡߏߣߌ</displayName>
				<displayName count="other">ߕߊߖߞߌߛߑߕߊ߲߫ ߛߡߏߣߌ</displayName>
				<symbol draft="contributed">ߕߖߛ</symbol>
			</currency>
			<currency type="TMT">
				<displayName>ߕߎߙߑߞߌߡߋߣߌߛߑߕߊ߲߫ ߡߣߊ߫ ߞߎߘߊ</displayName>
				<displayName count="other">ߕߎߙߑߞߌߡߋߣߌߛߑߕߊ߲߫ ߡߣߊ߫ ߞߎߘߊ</displayName>
				<symbol draft="contributed">ߕߡߕ</symbol>
			</currency>
			<currency type="TND">
				<displayName>ߕߎߣߛߌߞߊ ߟߎ߬ ߟߊ߫ ߘߌ߬ߣߊ߯ߙ</displayName>
				<symbol draft="contributed">ߕߣߘ</symbol>
			</currency>
			<currency type="TOP">
				<displayName>ߕߏ߲ߜ߭ߊ߲߫ ߓߊ߲ߜ߭ߊ߫</displayName>
				<displayName count="other">ߕߏ߲ߜ߭ߊ߲߫ ߓߊ߲ߜ߭ߊ߫</displayName>
				<symbol draft="contributed">ߕߏߔ</symbol>
			</currency>
			<currency type="TRY">
				<displayName>ߕߎߙߑߞߌ߫ ߟߌߙߊ߬</displayName>
				<displayName count="other">ߕߎߙߑߞߌ߫ ߟߌߙߊ߬</displayName>
				<symbol draft="contributed">ߕߎߟ</symbol>
				<symbol alt="variant" draft="contributed">ߟߕ</symbol>
			</currency>
			<currency type="TTD">
				<displayName>ߕߙߌߘߊߘ ߣߌ߫ ߕߏߓߊߜ߭ߏ߫ ߘߟߊ</displayName>
				<displayName count="other">ߕߙߌߘߊߘ ߣߌ߫ ߕߏߓߊߜ߭ߏ߫ ߘߟߊ</displayName>
				<symbol draft="contributed">ߕߕߘ</symbol>
			</currency>
			<currency type="TWD">
				<displayName>ߕߊߦߌߥߊ߲߫ ߘߟߊ߫ ߞߎߘߊ</displayName>
				<displayName count="other">ߕߊߦߌߥߊ߲߫ ߘߟߊ߫ ߞߎߘߊ</displayName>
				<symbol draft="contributed">ߕߥߘ</symbol>
			</currency>
			<currency type="TZS">
				<displayName>ߕߊ߲ߖ߭ߊ߯ߣߌߞߊ ߟߎ߬ ߟߊ߫ ߛߌߟߌ߲ߜ߭</displayName>
				<symbol draft="contributed">ߕߖ߭ߛ</symbol>
			</currency>
			<currency type="UAH">
				<displayName>ߌߞߑߙߍߣ ߤߙߌߝ߭ߣߌߦߊߛ</displayName>
				<displayName count="other">ߌߞߑߙߍߣ ߤߙߌߝ߭ߣߌߦߊߛ</displayName>
				<symbol draft="contributed">ߌߞߤ</symbol>
			</currency>
			<currency type="UGS">
				<displayName>ߎߜ߭ߊ߲ߘߞߊ ߟߎ߬ ߟߊ߫ ߛߌߟߌ߲ߜ߭ ( ߁߉߆߆–߁߉߈߇ )</displayName>
				<symbol draft="contributed">ߎߜ߭ߥ</symbol>
			</currency>
			<currency type="UGX">
				<displayName>ߎߜ߭ߊ߲ߘߞߊ ߟߎ߬ ߟߊ߫ ߛߌߟߌ߲ߜ߭</displayName>
				<symbol draft="contributed">ߎߜ߭ߛ</symbol>
			</currency>
			<currency type="USD">
				<displayName>ߊߡߋߙߌߞߌ߬߬ ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲ ߘߟߊ</displayName>
				<displayName count="other">ߊߡߋߙߌߞߌ߬߬ ߞߊ߬ߝߏ߫ ߘߍ߬ߣߍ߲ ߘߟߊ</displayName>
				<symbol draft="contributed">ߊߞߘ$</symbol>
			</currency>
			<currency type="UYU">
				<displayName>ߎ߳ߜ߭ߋߦߌ߫ ߔߋߛߏ</displayName>
				<displayName count="other">ߎ߳ߜ߭ߋߦߌ߫ ߔߋߛߏ</displayName>
				<symbol draft="contributed">ߎ߳ߔ</symbol>
			</currency>
			<currency type="UZS">
				<displayName>ߎߗ߭ߑߓߋߞߌߛߑߕߊ߲߫ ߛߎߡ</displayName>
				<displayName count="other">ߎߗ߭ߑߓߋߞߌߛߑߕߊ߲߫ ߛߎߡ</displayName>
				<symbol draft="contributed">ߎߗ߭ߛ</symbol>
			</currency>
			<currency type="VES">
				<displayName>ߝ߭ߣߋߗ߭ߎߦߋߟߊ߫ ߓߏߟߌߝ߭ߊߙ</displayName>
				<displayName count="other">ߝ߭ߣߋߗ߭ߎߦߋߟߊ߫ ߓߏߟߌߝ߭ߊߙ</displayName>
				<symbol draft="contributed">ߝ߭ߋߓ</symbol>
			</currency>
			<currency type="VND">
				<displayName>ߝ߭ߌߦߍߕߑߣߊߡ ߘߐ߲ߜ߭</displayName>
				<displayName count="other">ߝ߭ߌߦߍߕߑߣߊߡ ߘߐ߲ߜ߭</displayName>
			</currency>
			<currency type="VUV">
				<displayName>ߝ߭ߊߣߎߦߊߕߎ߫ ߝ߭ߊߕߎ</displayName>
				<displayName count="other">ߝ߭ߊߣߎߦߊߕߎ߫ ߝ߭ߊߕߎ</displayName>
				<symbol draft="contributed">ߝ߭ߕߝ߭</symbol>
			</currency>
			<currency type="WST">
				<displayName>ߛߊߡߏߥߊ߲߫ ߕߟߊ</displayName>
				<displayName count="other">ߛߊߡߏߥߊ߲߫ ߕߟߊ</displayName>
				<symbol draft="contributed">$ߥߛ</symbol>
			</currency>
			<currency type="XAF">
				<displayName>ߝߘߊ߬ߝߌ߲߬ߠߊ߫ ߕߊ߲ߓߊ߲ ߠߎ߬ ߝߊߙߊ߲߫ ߛߍߝߊ</displayName>
				<symbol draft="contributed">ߝߛߝ</symbol>
			</currency>
			<currency type="XCD">
				<displayName>ߛߍߕ ߟߎߛߌߦߊ߫</displayName>
				<displayName count="other">ߛߍߕ ߟߎߛߌߦߊ߫</displayName>
				<symbol draft="contributed">ߛߟߘ</symbol>
			</currency>
			<currency type="XOF">
				<displayName>ߝߊߙߊ߲߫ ߛߍߝߊ</displayName>
				<symbol draft="contributed">߾</symbol>
			</currency>
			<currency type="XPF">
				<displayName>ߝߑߙߊ߲߫ ߛߍߝߊ</displayName>
				<displayName count="other">ߝߑߙߊ߲߫ ߛߍߝߊ</displayName>
				<symbol draft="contributed">߾ ߝߛߝ</symbol>
			</currency>
			<currency type="XXX">
				<displayName>ߝߊ߬ߘߊ߲߬ߞߊ߫ ߟߐ߲ߓߊߟߌ</displayName>
				<displayName count="other">ߝߊ߬ߘߊ߲߬ߞߊ߫ ߟߐ߲ߓߊߟߌ</displayName>
			</currency>
			<currency type="YER">
				<displayName>ߦߡߊߣߌ߲߫ ߙߌ߬ߦߊߟ</displayName>
				<displayName count="other">ߦߡߊߣߌ߲߫ ߙߌ߬ߦߊߟ</displayName>
				<symbol draft="contributed">ߦߡߙ</symbol>
			</currency>
			<currency type="ZAR">
				<displayName>ߥߙߏ߬ߘߎ߮ ߝߘߊ߬ߝߌ߲߬ߠߞߊ ߟߎ߬ ߟߊ߫ ߙߊ߲ߘ</displayName>
				<symbol draft="contributed">ߥߝߙ</symbol>
			</currency>
			<currency type="ZMK">
				<displayName>ߖ߭ߊ߲ߓߌߞߊ ߟߎ߬ ߟߊ߫ ߞߎߥߛߊ ( ߁߉߆߈–߂߀߁߂ )</displayName>
				<symbol draft="contributed">ߖ߭ߓߞ</symbol>
			</currency>
			<currency type="ZMW">
				<displayName>ߖ߭ߊ߲ߓߌߞߊ ߟߎ߬ ߟߊ߫ ߞߎߥߛߊ</displayName>
				<symbol draft="contributed">ߖ߭ߓߥ</symbol>
				<symbol alt="narrow" draft="contributed">ߖ߭ߞ</symbol>
			</currency>
			<currency type="ZRN">
				<displayName>ߖ߭ߊ߬ߦߌ߬ߞߊ ߟߎ߬ ߟߊ߫ ߖ߭ߊ߬ߦߌߙ ( ߁߉߉߃–߁߉߉߈ )</displayName>
				<symbol draft="contributed">ߖ߭ߙ</symbol>
			</currency>
			<currency type="ZRZ">
				<displayName>ߖ߭ߊߦߙߌߞߊ ߟߎ߫ ߟߊ߫ ߖ߭ߊ߬ߦߌߙ ( ߁߉߇߁–߁߉߉߃ )</displayName>
				<symbol draft="contributed">ߖ߭ߙߖ߭</symbol>
			</currency>
			<currency type="ZWD">
				<displayName>ߖߌ߲ߓߊߓߏߦߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊ߯ߙ (߁߉߈߀–߂߀߀߈ )</displayName>
				<symbol draft="contributed">ߖ߭ߥߘ</symbol>
			</currency>
			<currency type="ZWL">
				<displayName>ߖ߭ߌ߲ߓߊߓߏߦߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊ߯ߙ ( ߂߀߀߉ )</displayName>
				<symbol draft="contributed">ߖ߭ߥߟ</symbol>
			</currency>
			<currency type="ZWR">
				<displayName>ߖ߭ߌ߲ߓߊߓߏߦߋߞߊ ߟߎ߬ ߟߊ߫ ߘߏߟߊ߯ߙ ( ߂߀߀߈ )</displayName>
				<symbol draft="contributed">ߖ߭ߥߙ</symbol>
			</currency>
		</currencies>
	</numbers>
	<units>
		<unitLength type="long">
			<unit type="duration-decade">
				<displayName>ߦߟߍ߬ߘߐ߬ߞߍ</displayName>
				<unitPattern count="other">ߦߟߍ߬ߘߐ߬ߞߍ {0}</unitPattern>
			</unit>
			<unit type="duration-year">
				<perUnitPattern>ߛߊ߲߭ ߠߊ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-month">
				<displayName>ߞߊߙߏ</displayName>
				<unitPattern count="other">ߞߊߙߏ {0}</unitPattern>
				<perUnitPattern>ߞߊߙߏ ߟߊ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-week">
				<displayName>ߞߎ߲߬ߢߐ߮</displayName>
				<unitPattern count="other">ߞߎ߲߬ߢߐ߮ {0}</unitPattern>
				<perUnitPattern>ߞߎ߲߬ߢߐ߮ ߟߊ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-day">
				<displayName>ߟߏ߲</displayName>
				<unitPattern count="other">ߟߏ߲ ߜߍ {0}</unitPattern>
				<perUnitPattern>ߟߏ߲ ߠߊ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-hour">
				<unitPattern count="other">ߕߎ߬ߡߊ߬ߙߋ߲ {0}</unitPattern>
				<perUnitPattern>ߕߎ߬ߡߊ߬ߙߋ߲ ߞߘߐ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-minute">
				<displayName>ߡߌ߬ߛߍ߲</displayName>
				<unitPattern count="other">ߡߌ߬ߛߍ߲ {0}</unitPattern>
				<perUnitPattern>ߡߌ߬ߛߍ߲ ߠߊ߫ {0}</perUnitPattern>
			</unit>
			<unit type="duration-second">
				<displayName>ߝߌ߬ߟߊ߲</displayName>
				<unitPattern count="other">ߝߌ߬ߟߊ߲ {0}</unitPattern>
			</unit>
			<unit type="duration-millisecond">
				<displayName>ߝߌ߬ߟߊ߲߬ߥߊ߰ߘߋ߲</displayName>
				<unitPattern count="other">ߝߌ߬ߟߊ߲߬ߥߊ߰ߘߋ߲ {0}</unitPattern>
			</unit>
			<unit type="duration-microsecond">
				<displayName>ߝߌ߬ߟߊ߲߬ߢߊ߲߯ߕߊ</displayName>
				<unitPattern count="other">ߝߌ߬ߟߊ߲߬ߢߊ߲߯ߕߊ {0}</unitPattern>
			</unit>
			<unit type="duration-nanosecond">
				<displayName>ߝߌ߬ߟߊ߲߬ߞߏߦߋ</displayName>
				<unitPattern count="other">ߝߌ߬ߟߊ߲߬ߞߏߦߋ {0}</unitPattern>
			</unit>
		</unitLength>
		<unitLength type="short">
			<unit type="duration-century">
				<displayName>ߝߊ߯ߘߐߞߍ</displayName>
				<unitPattern count="other">ߝߊ߯ߘߐߞߍ {0}</unitPattern>
			</unit>
			<unit type="duration-decade">
				<displayName>ߦߟߍ߬ߘ</displayName>
			</unit>
			<unit type="duration-year">
				<displayName>ߛߊ߲߭</displayName>
				<unitPattern count="other">ߛߊ߲߭ {0}</unitPattern>
				<perUnitPattern>{0}/ߛߊ߲߭</perUnitPattern>
			</unit>
			<unit type="duration-month">
				<displayName>ߞ.</displayName>
				<unitPattern count="other">ߞ. {0}</unitPattern>
				<perUnitPattern>{0}/ߞ.</perUnitPattern>
			</unit>
			<unit type="duration-week">
				<displayName>ߞߎ߲߬ߢ</displayName>
				<unitPattern count="other">ߞߎ߲߬ߢ{0}</unitPattern>
				<perUnitPattern>{0}/ߞߎ߲߬ߢ</perUnitPattern>
			</unit>
			<unit type="duration-day">
				<displayName>ߟ</displayName>
				<unitPattern count="other">ߟ {0}</unitPattern>
				<perUnitPattern>{0}/ߟ</perUnitPattern>
			</unit>
			<unit type="duration-hour">
				<displayName>ߕߎ߬ߡߊ߬ߙߋ߲</displayName>
				<unitPattern count="other">ߕ {0}</unitPattern>
				<perUnitPattern>{0}/ߕ</perUnitPattern>
			</unit>
			<unit type="duration-minute">
				<displayName>ߡߌ߬ߛ</displayName>
				<unitPattern count="other">ߡߌ߬ߛ {0}</unitPattern>
				<perUnitPattern>{0}/ߡߌ߬ߛ</perUnitPattern>
			</unit>
			<unit type="duration-second">
				<displayName>ߝ</displayName>
				<unitPattern count="other">ߝ {0}</unitPattern>
				<perUnitPattern>{0}/ߝ</perUnitPattern>
			</unit>
			<unit type="duration-millisecond">
				<displayName>ߝߥ</displayName>
				<unitPattern count="other">ߝߥ {0}</unitPattern>
			</unit>
			<unit type="duration-microsecond">
				<displayName>ߝߢ</displayName>
				<unitPattern count="other">ߝߢ {0}</unitPattern>
			</unit>
			<unit type="duration-nanosecond">
				<displayName>ߝߌ߬ߟߞ</displayName>
				<unitPattern count="other">ߝߞ {0}</unitPattern>
			</unit>
		</unitLength>
		<unitLength type="narrow">
			<unit type="duration-century">
				<unitPattern count="other">ߝߊ߯ߘߞ{0}</unitPattern>
			</unit>
			<unit type="duration-decade">
				<displayName>ߦߟߍ߬ߘߐ߬ߞߍ</displayName>
				<unitPattern count="other">ߦߟߍ߬ߘߞ{0}</unitPattern>
			</unit>
			<unit type="duration-year">
				<unitPattern count="other">ߛߊ߲߭{0}</unitPattern>
			</unit>
			<unit type="duration-month">
				<displayName>ߞߊߙߏ</displayName>
				<unitPattern count="other">ߞ.{0}</unitPattern>
			</unit>
			<unit type="duration-day">
				<displayName>ߟߏ߲</displayName>
				<unitPattern count="other">ߟ{0}</unitPattern>
			</unit>
			<unit type="duration-hour">
				<unitPattern count="other">ߕ{0}</unitPattern>
			</unit>
			<unit type="duration-minute">
				<unitPattern count="other">ߡߌ߬ߛ{0}</unitPattern>
			</unit>
			<unit type="duration-second">
				<unitPattern count="other">ߝ{0}</unitPattern>
			</unit>
			<unit type="duration-millisecond">
				<unitPattern count="other">ߝߥ{0}</unitPattern>
			</unit>
			<unit type="duration-microsecond">
				<unitPattern count="other">ߝߢ{0}</unitPattern>
			</unit>
			<unit type="duration-nanosecond">
				<displayName>ߝߞ</displayName>
				<unitPattern count="other">ߝߞ{0}</unitPattern>
			</unit>
		</unitLength>
	</units>
</ldml>
