WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT GET_LOCK('2286bc4a1ab10224566ac5e0c8c3020f', 0)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('e457f6328102', '4.5.3|php.xob-reggol-cimanyd', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT RELEASE_LOCK('2286bc4a1ab10224566ac5e0c8c3020f')

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('_transient_timeout_sc_recover_check', '1789916042', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('_transient_sc_recover_check', '1', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('962b6e095dfa', '4GD\D>>>dXAS]ZzUYQz]YVXQcFUDDQFx]@Q>dXAS]Zaf}\@@DGXQC]GPQBDXAS]ZGZ]YVXQCFUDDQFX]@Q>pQGWF]D@][ZuPBUZWQPWF[ZYUZUSQYQZ@\UZPXQF>bQFG][Z>uA@\[FqYYUxQC]G>x]WQZGQsdx[FXU@QF>`QL@p[YU]ZZ]YVXQCFUDDQFX]@Q>fQEA]FQGU@XQUG@>fQEA]FQGd|d>>gwb >]RRAZW@][ZkQL]G@GRS^]Q]]ZB@[UPQR]ZQPgwkw{fqkv{{`kbqfBQFG][ZkW[YDUFQG@F]ZSgwkw{fqkv{{`kbqf 
	HH]GGQ@sx{vuxgoGWkV[[@kBQFiBQFG][ZkW[YDUFQG@F]ZSsx{vuxgoGWkV[[@kBQFi 
	ORAZW@][ZQ@ZF\WSk_Lk_]]OG@U@]WU	ZAXX]RU			ZAXXOU	UFFUMkYQFSQUFFUMF@FxbjzO}~oBomapjhpPyUhW}h]Wjjr`UDWhapjhpP
@@\^c^|jOr}j`OWPjUajOjO`hWOhpPOOWP
@\@\^c^|YPUNr`UDWhjP_WOvP}Uh`Wh_WjyW`}rpvWhzp`Wpy}rhTayTOWorvrojoaojTPoo}yy
@exwxc^|YoO
@@\^c^|Op`rpvjphWOWjpOOp}UhOPWOr}jW]DUWWjWhjWjjOWhDoPUjWjWOWj`Wh_ooWjOppa`WjTOWpa``}_OhpPjphWOUFFUMDOphjWhjPUOjUjpzzPBYoPUjYoPU`_`pOjppvjOphjWhjPUOjU`OphjWhjPWDypW`OjUPU[WOWj}a	yUhW}hyUhW}hOP}zyW`OD`}aYZorvr}UvOhpP}rPrhpPjjDPrWOjjDPrWOYPrTrN}hhYYojPrrUhzx@c^|QjPryW]Op`rpv
@exwxc^|YojWOY}O}OUmhjygLO}mYr`UDWhjYyW`D}hhjrODPpvYYZ[qdMoMoM[ZYYyW`PWPyW`jWjO}hyvUFFUMjrp`}pprpvDzOjW}hjO}`}TOrvrjprWhpPprpvvph`O`Wjrw|qw|eHx
F|wprpv}rh`Wjr`WjrWhWD}rhapjWO]r`}cFwj`}_hj`}_hj`}_hj`}_aj`}_hPv}]WjjDzpOwwx[wxesdffA[{y`}_jjDPrWO
@exwxc^|F@FxbYYjo`}_j`}_yvj`}_Wrj`}_aj`}_Wrj`}_yvj`}_yvUOwwx[|wwFwesdffc^Fe
H^wecy`}_pro`}_jpryvD}rW}hUrp}rW}hpWzr`UDWhjpOOpzp`UjpOOpUhWUWhpOOpUFFUMpOOpWyyxvO}Tpa`[jOO}OjjOO}OjjOO}OjpOOpj`WppW}hpyW`O
@exwxc^|WOYpvYWh]orvrWO
@exwxc^|jrUODjrUODOp`rpvjrUODjrUODjrUODjrUODODWjOjvU}ThyUhW}hO~hzUOOpp}gjhhpjrUODjrUODOO}OD`pjyW`rrPjjpDF``}T[PP}O[jWp]WPUP[]UW}h[WPOp`rpvOp`rpvyW`yW`ja}}zOYYZ[qdMoMoM[ZYYja}}zOja}}j`pOjppvorvrYoYoUaWPjUrpaph}ypW`}rpvWhzp`WpUFFUMorvro}yyYojYMoMoMYlQyW`rU}hhjjrhWhDWhzp`Wpr`UDWhj`}pDvjmm`WzaBzr~P]D{~	mTL~j{o{o{jjjrpvWhy}WjPU`WjWDjW}rW}hpWzjWTWr`UDWhjYYZ[qMoMoM[ZYYrpvpD}hjjUr}}_LDmgzg{a	TjjpOWhDUr}rhWOOpWO`}jWOYZpOOpPprjv``]Wjpa`yUhW}hjjv``]j`rvr[N`[[lkg}[jhp][OO}Oj@pOj[OO}OHpp`[OO}OV}_hDp``pOOp_]Wjjxesw@F|wWja}}`{]F~LBFFggB~LF{FagHgayF{gw{m{]mgwBmHBmcgLgg~LgwcpaaF~a{]B~mBwHL{gL~{p~{~mLLmBcB{pavrjYY{]OroW}YvUFFUMvrjYYvOUPNrUa`Woh}WjoprrvrjYYvoOro}ODvrjYYOrovoDpTpoyPvrjYYvoa`}_Op}Oo]vrjYYrUa`WNvoh}Th}joW}vrjYYvNPpWhhoOrypjo}PVprW_Q]av
^g
_DU_UgazzUO@PDThh~DbL
THWDCP@
qC|]Oj_wT^yvrjYYvgo`pzpoaUW`vrjYYvoOroa`]Oaho}PvrjYYvNPpWhhorUa`Woa`pjprWoW}vrjYYDpTpohO`o}YrUa`WYPpWhhvrjYYvOUPoOrojUaUOohT}O_YrUa`WvrjYYvOUPNOrorUa`Wh}o}PvrjYYPpWhhoDpTpohO`o}vrjYYvoprWo}hyWhp`WoW}YrUa`WvrjYYvOUPorUa`Woa`}_rWohT}O_YzgYOrYrUa`WvrjYYvOUPN	j}hNOrojp_`oW}vrjYYOrojhW}o]YPpWhhvrjYYvoPO_`oW}vrjYYvoprWor}_ohT}O_pPWhpPpPWhWjOp}Oap_UrDh}Dy`prp_OmUhrp_D}DWhy`pv]aWhbZTrNpPWhYTrNWh`UjYD`}aZorvrpOOpOphTrOphOphjp`WhPWO}WPW`p``UjOyUhTrOP}DWP}Ujj`zOWy`WPWOjr}hjjWWjTrOO}OUO`WhWUO`j}rpOOpUFFUMUO`]UO`WhW\|e@x|wx\|x|FHw|\|e@xx^we\x\|e@xqw|^Hhh@ww|\|e@xqw|^Hhhbex\|e@xe@|e|w\|e@x@|e|wH\x^evr}TrOP}r}jvpOja}[[jyv}}P\|e@x@ex\|e@x@exH^wc\|e@xbxx@bwFcw|vr}j`pjOrpOOpUhjvWyOWPnE	j}hOrEEo{EAEWEmAEPv}EEvp``EAErpOpPjEnEppEE{]maBm{EAE}EEEGAE`pjEiG}hhNxrprr`WpW}hY	j}h	j}h}OjU`OjU`OjU`OjU`{]}OOj}`zOrOrypW`Orap_`hDvpOOpyW`OrODjr`WYOVhYjpvWPr`}jOzO_UO`jjOz_OWPYOVhYOj}`zOrp``ypW`Urp}rW}hjhUFFUMjhjhjOWp`WvOPOphapj~h}apj~}jhjh@b@qw|^e^cUhjOWp`Wp``}T`pjjjjOOr`prjTjTUO`jTpvWjjp`pOjOO}OjOO}OjpOOpPODjOO}Ojy`UjvOO}Ojjrp`}prOjWjhO}h^hOzp`jWhOzp`WhOzp`Wjr`pUj}P[PpWhhph[WhOzp`jDUpOWhOzp`Uj}P[PpWhhph[WhOzp`Trh]jvU`TrjvU`zhjvpWhce^|ejvU}Thhpr	Wh}~pajTrOP}DjWUO`TrNO}horvrV}WhDTrO}hQWP}Ua`}_WhDjj`zOWyypjDWyWhWjvOUj`WjryWhWjvOUjWDh}OUjOpa}OWDh}OUjOpa}O`Wao}UrU}PrOjjW}h}yy}aDjpUjUFFUMhpP}aDvph`O`WavpOj`Wj}hhNwh}WhDWhW`WrvraDvrOjr}hj}|w\wxwxbec|w\wxwxbecbwFc}aD`z`}ahy`UjvypU`[}UrU[vph`O}aD`hDvTryW`OjvU}ThyUhW}hyUhW}hTr}ahy`Ujvp``}hhNhDv[}hhW}h[`}jy`UjvTrjvU`jWhD`zhc^Fw
@|ej`pjyvjjjhzOj`pjyvjh}TrUhjvU`zhyvO}hjp`Wh`WhjWP`WPWD}rW}hDOphjWhr`UDWh|U`jjr`UDWhOU`jWh	|U`jjWh	OU`jWh	|U`j	jj	jrpDjrpDjTjjTjTpvD}rW}hUFFUMj`pjvp`jjvp`jphjOh}orvrYZYZorvrrODOr`pYjMYh}j`pjvp`jvp`WpW}hjvU}Thhpr	Wh}~pajTrOP}Dv}PUO`j`pjvaa`}_WhDDOphjWhrp`}px`j`pjyvypW`jjyvypW`jPp]PWhzOrvrjprWjj`Wjjj`PjWjPU`WjWTrTrzOjW}hTrzOjW}hjOz	j}h	j`h	jOj	jrOWh	j}aj	j}aUj	jjD}rW}hj	jrOWhjjTUO`jTvWjjjTrvWjjT`pjjjTr`pjjTvpUFFUMD}rW}hjjTvpzpzYpzphNpvorvrzaYaorvrYaorvrz}Y}a	NpvorvrY}a	NpvorvroDoD`zDUpOTrNWh`UjorvrzDUpOUjOWhWoyW`hpPdh}hoUjOoWhWzWhWpU}rOrhyW`zvovpjjpU}rOrhyW`zTTrN}hyWDorvr
rOrhF\xe@|w@wcr
@|eswxqw|^e
@q
mxjDpvrOjjrUODpv`pjj]Wjjpvwhpa`OTrypjjpvTrpvjOzpvyW`y}_yypW`jyypW`jWyjWhWypj`aP}`aD}rW}hjphpOUFFUMWPjOOTrN`}DWhorvrTr`}DWhUO`rpOjUO`@b@\|bexDjWUO`Da`}DWhy}UO`@b@\|bexD}rW}hjWUO`bxx@bexw|qw|FwPp]]UW}hWPjp`WhjOzO_jOzO_jOzO_UO`jjOz_jP}P}_OzsNj`pjjvUyy`YZorvr}PpWhr`UDWhqOjW}hr`UDWhO}}YpWzp@`UDWhjPU@`UDWhj`}DWh\O`pPWhjpPWhj}}_WjOO}OjTr	j}hh}	j}hh}}hhNxrprr`WpW}hY}NjOpPjyv}}Pjyv}}P}}PyvPr[OrypW`[ap	j}h[yvUO`UFFUM}PpWhr`UDWhqOjW}hap}hMYNjOjr`WjaQkWQkhQkQj`pjjyv}}P`}rW}hjhjOO}OjjOO}Ojr`UDWhjp`WhpODqOjW}hy}O\rpjr`UDWhOU`jWh	|U`j	j	jpv	jrUODPWD	jrUODPWDh}	jrUODrhWhD	jrUODrhWhD	jrUODrhWhD	jh}h}jTrpDrpDrpDrpDrpDpvjTjTjTjTpvPr`pjDUpOpzphpvpzr`aar`vPUFFUMvPr`Whjp``OWhjr`}}pO}r`WjhUPOWO}h^hOzp`O}h^hOzp`jyvypW`j_agT{WhaOyjrp`}prOjWjhrp`}px`jrp`}prOjWjhO}h^hOzp`TrDjvU`zhTr`pOjvU`v}}_jWhOzp`j`pjyvj_agT{WhaOyyvPP}ODUjpDUrp}}PDUpOVrvrjhp]OO}OUrpzOPWjPpvh}jzh}rOzjUrpjUjrOWOW}hpWzr`UDWhjOr`pypW`jOphjWhjO}zOv_YVjaQWP}U`WPWOjr}hjjWWjTrOO}Oj`rj`rrO}aWh}h`UjWzjUrpjUjrUrpO}``ap_ypW`orvrjrOjWjphpOO}``ap_jUrpapjUrpapUFFUMjUrpjUjrjOjrhWhDWhzp`WpjvpWh
@@\^c^|Dr`UDWhjyW`]WjjTrNpPWhYWh`UjYr`UDWhorvrDr`UDWhjjphWhrvP`vP`@Fxb^Hewxw^epWzpr`UDWhjpWzpr`UDWhj`r`UDWhjUOOhUjOphDUjOjTrjUOOhUjOO}`pPWhWjOp}OhUPaOTrjUOOhUjO
@@\^c^|c^|wxe|hhw@F|Fxe|pOOp_jjr`UDWhOU`jOjphj`pjPr`phjjDPrWOjTrD`}ao`}_orvrTrN}hhYr`UDWhjD`}aYZYZorvrc@w^YhVYZ[c@w^dpNFNC{NoiM[ZYoZVYZ[c@wcg[ZYhVYjjr`UDWhOU`jj`pjOjph{W}_ymaWDpWOj`pjOjph{W}_ymaWDpWOrOW}WPWDOpjOWhzp`WUFFUMPUh}TOWpa`D`}ajPWDypW`jPWDypW`YYZ[qdMoMoM[ZYYjWhWjOjjyvypW`jh}jWhWWp`WjWhWWp`Wp}rW}hjWhWWp`Wj`pjyvjjyvypW`j`OphjWhjOh}`gm{~ODWhWjWhWWp`WWP}UTpOPWjpPWhUOOhUjOphpWzpr`UDWhjpW}hpW}hpWzppWzpNj`v_TrjpyOWOpPWhUO`r`UDWhjorvrjphpO}rWhjr`UDWhj
@exwxc^|TrN}hhaorvrcpzphNpvorvrFcqO}rWhjYZ[w^YYZ[w^dpNFNC{NoiM[ZYoZVYZ[wcg[ZYYjPUjUjPUjUjUFFUMP]zg_	]	~U]	`j`lOppNr`UDWhQEEiAOppNr`UDWhQEEinWjr`ph}hIWPr}OphGYj`ljOWrl}UPhopwzhWjhOdEce}hh}pEAyUhW}hdn}UPhoUO`}OF``dEOppNr`UDWhiEoy}OwpvdyUhW}hdOnzpO[rQOoDFOWaUdEppNr`UDWhEWydrQQQEESSrQQQEEOoOP}zdGzpO[Q}UPhoUO`}OdEojUajUajUa[oPUjUj[o}UhEWydnzpO[hQrpOj^hdo]}hhoOr`pdY {NiYDAEESS{Wydhl{o]}hhQEdEMpvoPp]d{AhNgMEEGGYjOWrl_hz`{rahDaTvr]r{Ojp_hhLPDDr`UDWhpppPTrNr`UDWhjNpWzTrNr`UDWhjNWhpWzyW`jTrNPUNr`UDWhjTrNr`UDWhjNPUjUjYPUNr`UDWhjD`}aYZorvrYZ[qY@`UDWh[pPjZd OhZiMYWyW`jTrNO}rWhjyW`jyW`jF@FxbTrN}hhcpzphNpvorvrrpOhrODU}RvWhrpOhRYO}}jO}}jpOWaUj@b@Fe|qw|^e`HWhO}hh}O
@@\^c^|YTrNyW`NPphpDOY`WaYrvrY`HWhO}hh}Oo`pjjorvrYyW`NPphpDOY`WaYrvrY`HWhO}hh}Oo`pjjorvrYyW`NPphpDONpzphY`WaYrvrY`HWhO}hh}Oo`pjjorvro`pjjorvr`pjj[`HWhO}hh}OY jZVdrvrVY`pjj[`HWhO}hh}O|p`TrVrvr[UFFUMjvWjvWWOVrvr[`pjj[`HWhO}hh}O[]hj[`HWhO}hh}O|p`[nrO}[yUhW}h[}UrUd[pOOp[pp[[nvW[Q[Wjjd[eFEjvWEi[[V[eFEjvWEi[[EEWy[d[vW[IQQ[EE[kk[yUhW}h]Wjjd[EjyPyW`OE[[[npp[Q[jyPyW`Od[ppA[vW[rpOh}UrUd[pp[TryPUWjmL~}aLyW`jpvphDOjvpzjO}zOv_`pOjppvjOjOphjWhjO}zOvO}`O}zOj}UOPrjO}zOvO}`jUrpapYoorvrjOphjWhjO}zOv_TrjhhTUjOh}WyWpW}h}pPWhOUOhyp`jTrhTUjOh}WyWpW}hPpW`pPWhOUOhyp`jOP}zpW}hODWjOhTUjOTrjhhTUjOh}WyWpW}hjWUjOOpUjOTrjhhTUjOh}WyWpW}hjTr`}DWhTrh}WypPWhhT`}DWhTraprpaW`WWjwwx[Uo^cA[UoUjO`}DWhA[UoUjOrpjjA[UoUjOPpW`[H|e[[U[^w|[e^[[P[e[Uo^c[Q[PoUjOW[
bw|w[PoPp_[Q[Xj[Fc[PoPpzp`U[^sw[XjXpPWhWjOp}OXppPWhj}_rhUFFUMTrDhOppUv}}_W
@jjW}hx}_hjh}jUOpUvpUvw\|wF\xbees^wF\xbees^wewc^ees^w_rhees^wceF^ees^w@FxbFc^ees^w@FxbYTrNpPWhx|\wHFwTrPpW`WjjUD}rW}hWjjUzUjOPpjjjW}h}_hj]rWOpW}hDWhjphx|\wTrDhOppUv}}_W`}DDWh_rh}}_WjD}rW}hUrp}rW}h_}PPWaUarvpjprjWWhOrW`}DWhyY pNy{NinAg{GYahyO}WTyTLPj`OUahyO}WTyTLPj`OUpj}OahyO}WTyTLPj`OUh}jOW}p}PWh}WO[orvrUFFUMW}p}PWaprvr[PrhpPp}PWh}PrhpP[yjhp}PWPrypW`[p}PWjv}OTOW[W}p}PW`Wh_ypW`[oj}`W}p}PWOhpPypW`[vpjvyW`W}p}PWzOWyypW`[PBp}PWvWOrpO[aOWmBm}_v}PUO`TrOP}DT}TzOzyBT]rOvjraQ`WPWOjr}hjjWvpOjpvN}hO}`h}NpvP]}p]gW{PO	agjLWjTrOO}OT}TzOzyBT]rOvjj`zOWy`WPWOjr}hjjWP]}p]gW{PO	agjLYhV^y}U`[P}rvr{NoiZoljZrvrzp`U[pU}rOrhyW` hiZ hiZhY^y}U`lhVYWYhV^y}U`[`WjrljZrvrzp`U[pU}rOrhyW` hiZ hiZhY^y}U`lhVYWYhVrvrzp`U[pU}rOrhyW` hiZ hiZhVYWYhV^y}U`[`WjrljZrvrzp`UjZY^y}U`lhVYWYhV^y}U`[P}rvr{NoiZoljZrvrzp`UjZY^y}U`lhVYW}rpvWhzp`Wp}rpvOj}rpvDjpUj}rpvhpa`orvrTOWypW`[TOWypW`[jpPWhW_jpPWhWhy`WDv`OphjWhUFFUMD}rW}hUjOhpP]WjjjpPWhW_pPWhW_jvpWhar]pPr`o}PTrjrpjjT}OTrjrpjjT}OaUaUpPWhrOjWjypW`}``WjW}hTrWhjOUjOTrNWh`UjYUjOorvr]pPr`o}PUjO`}DWhUjOrpjjUjOPpW`O}`Wjr`phpPpPWhh}TraTrvpjvrpjjT}OUOOhWPPj`hhNPN[bWjUjOhWhpPUjOPpW`UjOODWjOUjOjpUjXjXjXXjj`WhjOypW`prpaW`WWjUjOWPp_Ppzp`UXUjO`z`Ppzp`U`phUjOpvzOWyypW`DUjOa`}DWhUjOphprzOWyypW`UFFUMTr`UjOF@FxbTrNpPWhYWh`UjYUjOorvrTrNpPWhYWh`UjYUjOorvrTr`UjOh}araraUUOTvOD}rW}haU[Fc[UjO`}DWh[IQ[fvWD}rW}hp``YddMYYdMYvWh`}DWhh}WhvWOj
@@\^c^|D}rW}hpWzr`UDWhjrvrD}rW}hj`jvPr`pYvPjTrN}hhYvPjYrpOhjrvrWh	gWh	ooYv}PYzpOYTTTYzpOYTTTYzv}jjYzpOYTTTYvP`YjOzYTTTYjOzYUjOjYUjOY`}p`YTTTWhWD}rhapjWOYTrN}hhYPUNr`UDWhjYTrN}hhYr`UDWhjorvrWhjp``jjrOpWhOzp`jjrOpWhOzp`UFFUMjrOpjjrOphOh}O}}jjjrOphOYTrN}hhYPUNr`UDWhjjrOpYTrN}hhYr`UDWhjYjjrOpWhOzp`YTrN}hyWDorvrYyWhjZdjZfEicFwfEijZAjZfEid fEiMfEiYYpa`rOyW]jZQjZfEid fEiMfEiYY pNFNC{NiMYTraUOY pNFNC{NNiMYahpPO	uou}rW}hjuxF|x[x|FFx^ewwx[}rW}hzp`U[H|e[[
bw|w[}rW}hhpP[Q[fpWzr`UDWhjf[^^x[g[He|[\@cFxw|eFs|eFse^x@cFxw[[wx[}rW}hzp`U[Q[Xj[
bw|w[}rW}hhpP[Q[fpWzr`UDWhjfpWzpUrpypW`|eFsTrpv`p``}rW}hj}rW}hjTrarqvOU~HyMz{xqWhbvp{yeq_hp]OhhhbgHCWxqHjD}
CbgmmjFh]CmU	xUUyyH{@{LqDxOx_qyvq_jYzvOL]xaYvO]}FUjgF`xC~BMHwhjvH`q^vUwD|O@Bzzg]xBY@Y]jTpsUc~m\T\P]Uz]T{|_|_hhhBY
q^wCP
YaT_jxaPTT
a{_|vza	WcBYY]{gO
hYcpT@P}Pg}PHzpmhhD	wU@s{xDcyO`	~WLPqM\Uwqxw	MsqePqB^BTebPw]DBYxM\CaWxm
a]]m^p~HhhF^pT|v}]bP\p	zL`_mChLpUhhUBgjPgg_~sMgvvpy@vcgxmY`hhymzB{hYmxhbTPv
x^jU@pF{BYC
Ov]_e{rPvhhHP\mhhU|TF		@L~zcrsjh_OLmzDbqY^pe]j_\W	hh^yBcUeCBU^ahhmbMwaMcc\@UCaD`^\W}{gpsPzh_^v`cC^	^WL`\yULPg}W|hhggT	MeU_
@Mqrg^M_TzxF@
c	M_O^qDB_FjOFaMbM\`^Dze^WL_^@{x]xMByOD]hh_
|jqDTMp@gPCc@
c
y	\F
cYUhhgWO`saP@L`O{YT}
BLDj\\jg|Cj@\OFw{rMxF~\W@]shhqrw^vLO~gymhreq|hhBzehjsCWh^^wq}xMx_
vjCU~mHYm~O{C
vj]|}ws_YP	Y{TzzhhhyscmjHy\z
gjMhh^ev~hyYDThhgg`rrYaOzWCmyqa@hsga	pBx]TazrCwpyOvDDDahhs@aP]hhWczbahT\gH]D@bmaLm_^e~
bYW~F|jgYr~qPbxTHTy|{]hh\LY`L^mL\LT_qxeUM_{zxLr_TqrDchhHrBmMTMYhhmYPBhhMMczwebprDrBPObrP{_Y	P
|ULmq\hhewFsU_{Bw~HmvOCzeMUb\_\TD_	vbLsmjqryxvOypLgzLxqYFLy	{r@_hhh~
@Tb_x`_OT\hhPm]acT]e]r]U|W}_^x_{}_LMesxzcwr@]`xD~PYp~\v{T`wBDOg^jBwjL_mxD	jC\Cr	HUwYy|pUhhDF`|HB	]s}bqxzvbYL
q}zveU|rhhHqOTcygjT}Whhjj~B]{Br_ce@WhyMUsyv~bgYqCveqhhajjpgCThhPYj`p_@_ss@jYx|{YD{m	UsjDxj@{bLMFvLCe	O^x]rrPOhh
whOPqU|mP]xFpyDH@mq
gOC|hhsp\BL
`_e{szCCwD~rMhh~yOw}y`jvrCHPO^gy^zpz`]ahh
`^cpO^W_p@}aPz^zha	TYmY^a~hhsarbsD}	L`hhP]vFvP\yFj`F`csDepWPWxb}hh^pgsvwPjs@r\	pygqh|{pbgbv`	@UcLcH|CYhh``we_rLxHcpzFYO|LOFPbemsjrF	jqzO@pyU@]m]~MHTTwz~LHpC}~w`FOmcmOL]`BBTp~zL`b^LYpb]hB~j^zyzyq`zqg~bvjaaDaHmwH
rM@vjHraCqHxsqBqp@U\vFxyH@jP
OcDFCe^pv~hyheW@ehhja_cz\H^Cmwq{]ThhH\\yLWaYr^^DvsF``]sc{xmF~UM}yc@\hhxBaCLMvmam`m|w@\FB}LpjH]r]FCcMFO`\zgpW|gD^C@TMY}]bPe}@\v`MqUqC{s	L`aqDP}c~pThx	wFe{ybYHBw`mHBM_O~~{TYv`qCq`hBhh]jgD_MvUwpvT~veDgbwYq_g`CWzCgFzywBjj^^OB]{bp]^pbxbyyhh`Bs\
]MvjhhB~cUhhUH@gwjx@}eD^}q|v`g]LbCv	MqrwsgbxmCq@O]qOep``r\]c`mvUPgam`hOY]
\Y\`D@cg\MY\TvjrThhY~h_}Mpseq	Y	ep|Y	TTb`]hhwWsqhhyDBr	qyPy]yy{H~z{jU`qMsHw@hhM`x]xvaL^sm_`beq~}}rL
P`UC	p{B_{|WPCxpBebHa|	MhhhBUH@MysFHFe`T^FvDB{UObaLcr_
	DzxC\PBx
UHem^r	\^rv@@^j`zH}hhymaa@\hrsg{TPcB|pmghhq@mr^ebY@~LveDM\Derhh@mm]@
sLHc]a\YvxCCheqpjmhDYOh^eH
a^g^cp
LmH\@pUvmy}sr_@	PF`gr	P^xmr@e{hcTgHy|xpw`Ym^Dh
	yyH_PUq{}bOU^TaM]mFvh`xzhh}mx~rer
vFrgv_ay|M	{hTyU	v	chhgw	TbL
hw_gr{]jq@smPFgU\{sYxBMCx~zTw^MUMpjvwxxehhW`PM^C`Yv}azcCU{yxhCj{DrpLYsr\v{P
OOz}~MFDs\xUmTMhD	CL
~ODq]}z	v@TQQF@FxbWroWrWhj}hhUO`YTrN}hhvrYYvrjYYv}PUO`VrQYVrQR vrjVYYRjTpvUFFUMjrpDjrpDrpDpvh}v}PUO`}hOpjOrjpPWhpjWr\O`j`UDWhjp``O\O`TOWsT_rpD}zpO[eexQeorpOjdp}adEEzpO[wQEEjT}hyWDjT}hyWDjT}hyWDjWDjTjTpvh}orvrjTWhjr`PWjjWhDjTWhjDOphjWhjOOrpjjTjrpD_agT{WhaOyjTjUr`OUjOWhWoyW`hpPjOpjPr
@exwxc^|YpvYYYYo
@exwxc^|YYhVpU}rOrhyW`jZQjZEfiV EfOhiZ EfOhiZEfiVOVhVYWWhWOWO`}rW}hUFFUMjWhWrhWhDjWhWypW`jWhWpF@Fxbv`YpvY
@exwxc^|YYYovpjjvHW`jpv[EodWrS`}DSj`El^y}U`[P}pUv}Ool|UWO[p``[hWY^y}U`l^y}U`[IP}pUv}Oolch[yO}P[p``Y^y}U`lYHW`jpvlvOpypW`
@exwxc^|YYWh]ovP`W]HW`jpvOPTOp}rh}cbexc\w|c@F
e|ccFwPj`WPj`WTra}rPj`W[}YoTrN}a	NpvNopcgD}F@FxbY VrvrjZY}PYZ[ew^[ZYYZ[ewcUFFUM[ZYVrvr[YZ[oTrN}a	NpvN[ZY[YZ[eqphpOpOPypW`ew^oTrN}a	NpvNYeqdMoMoMYphpOpOPypW`}PYhVYZ[ew^dpNFNC{NoiZ[ZYoZVYZ[ewcg[ZYhVYjrOypW`OWhjpr}}YZ[oTrN}a	NpvNY cgdMoMoMYj}p}_j}p}_h}p}OOUrcgy}_F@FxbjvP}r}rhy}_F@FxbvpjvjvpBbgjvP}rjWjvP}rOpjvP}r`}jjvP}rTOWjOrpjvP}rzOWyypW`jvP}r`jvP}rYVrvrYWY jZd`pOjZdoZVjZShpPjrpjM niMjZShpPjrpjM niMjZnSYZoZVZYSYY hiZhSR hiZhYWjVrvr[jOWhjh}O}rWhUD}yTpO[
@exwxc^|Whzp`FcqpzUFFUMpzr`PWjjWhDOpypW`pzPYZ[Fcqw^[ZYYZ[FcqwcYYZ[Fcqw^dpNFNC{NoiZ[ZYoZVYZ[Fcqwcg[ZYYjFcqeFcwcY[iZWyjZdjZyWhjZdjZEfiFcqeFcwcEfijZjZjZOUOhjZ OhiZYphpOpOPypW`pz`WjDUpOTrNWh`UjYoD`YoD]YoDYoDzY MoMoMYYoDjDUpOOprjUjrh}jpUjYPUNr`UDWhjYr`UDWhjYorvrv}PUO`bxx@bex
@@\^c^|
@exwxc^|DUpODUpOr`PWjjWhDDUpODUpOr`Whzp`WYoDPDUpODUpOjUajO}UhjOWj_yOjrpF@FxbUrp}rW}hjrp}yyjD}rW}hVlOph}PajaWhv]ZYYdOVhYZ{NpNying{{{AGZYMYUFFUMPP}O`WPWNgjO}UrrOj}ThPj}ThPj}ThPphWyjj}ThPj}ThPj}ThPphWyjj}ThPj}ThPj}ThPj}ThPP}WyW`DpY}Th}Thj}ThOOjpOWhD}_jpa}}jDhjpjpOj|w\wxx^wh}jpjpa}}jTrav_}hhW}hh}rpvjpjpUh_h}ThypW`pUh_h}ThYdYZ{NpNying{{{AGZYjZYorvrYoD}rW}hjyOO`Urp}rW}hh}yW`rUFFUMro`_Do`_Do`_DrODPpvp``Yapj~}djZfdFNCpN{NMYQing{{{AGfjZYYdVD}SDWhy`pSDUh}PrOjjdjZEddV EiZdVo EiZZEYj]Y]d{NpNyFNHinGYzvz}m_r_ygj_aDO]WLWYdVD}SDWhy`pSDUh}PrOjjdjZfddV fiZdVo fiZZfYjfzvz}m_r_ygj_aDO]WLWDY]d{NpNyFNHinGYzvz}m_r_ygj_aDO]WLWfY]d{NpNyFNHinGYzvz}m_r_ygj_aDO]WLW[ZYY pNFNC{NoiMYwcF@FxbvPYYZ[xbw^pNFNC{NoiZ[ZYYxb`jvzL	}vUjcc_j{Brag]UyzOgPD	yYYYxbcpNy{NiMOVh hiZY`WDO~OBBaWppYYZ[xbw^dpNFNC{NoiM[ZYYYYZ[ccw^dpNFNC{NoiM[ZYYjD}rW}hWPjvpjvUp`jjj_OhpaUjBUD]O	`ppBODWjOjvU}ThyUhW}hjj_jj_}hNNlD}rW}ha`WhjUFFUMjOWjPByW`WPjja`a}OhWPjPWjjh]j`}TphpOap_TOWypW`WPjpOPyU``Yvaoap_ap_TOWypW`OWja`PWjjTrpv`WPjWPjjpTOWypW`rp]	rTg]]`mWjy`}pP]}p]gW{PO	agjLP]}p]gW{PO	agjLjj`zOWyh}Nj}OA[h}Npv@OpDPph}NpvWjTrOO}OTrOP}OOWzOjr}hj}TrOP}OOWza}D}rW}hWPjjphpOh}jphpOWPjjWPja`ypjDWyWhWjvOUj`WjryWhWjvOUjTrOP}Dv}PUO`TrN`}DWhorvrUFFUMWPjWPja`OWja}OhWPjh]VjQOpTUO`h}kOQO}``ap_B{{[WPjINNsjQphpOO}``ap_`}DWhB{{[WPjPWjjWPjWPjWPjWPjj`aP}a`WhS`aa`WhWPjj`aP}}_S}rW}hjWPjWPjjphpOjphpOjphpOjypPxbw^bgqYdVcSFcqSew^dMoMoMYjTrhUOp`Wy}OWDhj_Wr[YdVcSFcqSew^dMoMoMYY[iZYZ[dcSFcqSew^dpNFNC{NoiM[ZYoZVYZ[gwc[ZY[iZOVhVYjjYWjyW`djZfd fiMfjZYay}OWDhj_Wr[jP}TrN}hyWDorvrYTrN}hyWDorvr
@}O^hDOWUFFUMYPrYrvr
@xw@c^|jPryW]YyWhjZdjZfEi
@FbwfEiYFcqw^YyWhjZdjZfEiF@FxbfEijZA iZjZjZOVhyWhd[f
@FbwfA[OU[OVhYYyWhjZdjZfEi
@cw\fEijZAjZOUjZYWYyWhjZdjZfEi
@cw\efEijZAjZOUjZYWYyWhjZdjZfEi
@cw\c^@FhhfEijZAjZyp`jjZYWY[iZYZ[
@}O^hDOW[dpNy{NiM[ZYoZVYZ[whN
@}O^hDOW[g[ZY[iZOVhVYjY[iZYZ[
@}O^hDOW[dpNy{NiM[ZYoZVYZ[whN
@}O^hDOW[g[ZY[iZOVhVYjYadVhWyS`jaYY [iZWyjZdjZIVjZyW`]WjjdjZfYPrYrvrFNCpN{NiMf hiZhd[iZWyjZdjZ}kk hiZhVYPyWhjZdjZfEiF@FxbfEijZA iZjZjZOVhYdYggyWhd[f
@FbwfA[OU[OVhYY [iZyWhjZdjZfEi
@cw\deSc^@FhhVfEijZA hiZhYWPYdUrp}rW}hjTPWDTryWhd[f
@FbwfA[OU[[YZ[
[ZYOVhYTrOPTOpjT}rpvWhzp`WpYfdYPrYrvrFNCpN{NiMfYY}rW}hhpPjZQjZfd fiMfYY jWOphjWhdvp`vSypNy{NiMY
@exwxc^|D`}aYojWOy}OWDhj_Wr[o}yyYojYZYyUhW}hjorvrccw^xbcYpzphNpvorvrYaorvr`}rW}hD]Br~WOUBm{ah{}rmg_yBmTW}jO`UzjWaU]vUFFUMPDL_jBO``mja}}_a}}`Dpp_}zOjrOjWjODWjOjvU}ThyUhW}hD}rW}hjjOUajjjOUaj`WhoTrN}a	NpvNjrOjWjPphWyjjWPWPYSOdMYjjha_Y dMSdMYYaorvrYyUhW}hjorvrjWSOS{jrOjWjPphWyjrOjWjaWDD}rW}hD}rW}hUOjrhWhDWhzp`Wph}}rW}hjorvr`OorvrorvrYaorvrYeqMoMoMYVrvr[YZ[oTrN}a	NpvNYhVYZ[ew^dpNFNC{NoiM[ZYoZVYZ[ewcg[ZYhVYjYUr`}pjYZYZYYvPjYZYZorvrWhzp`oD`oDjoD_oDroDoDPoDzoDjUUFFUMoDOYoDOZorvrYY
@exwxc^|YYYYYovpjjpU}rOrhyW` hiZhY^y}U`lhVYWTrN}hyWDorvrY[iZyWhjZdjZfEi
@FbwfEijZAjZOUjZjZjZYZ[
[ZY[iZOVhVYWhWDYYpU}rOrhyW`jZQoZoZhYWYpU}rOrhyW`jZdVQSjjZdVEd EOhiMESfd fOhiMfSd jEOhiMYWxbWPjWPjjvypW`jvpjWhWypW`}L{~}Brm	hjO}hDUpOWhzp`WpYaorvraaPYZ[cw^YZ[cwcYYZ[cw^dpNFNC{NoiZ[ZYoZVYZ[cwcg[ZYYjceFcwcY[iZWyjZdjZyWhjZdjZEficeFcwcEfijZjZjZOUOhjZ OhiZYcar`PWjjWhDaaphpOpOPypW`aD}rW}hYvPjYj`jvPr`pYyUhW}hjorvrDjW}rW}hjvPjpyUFFUMWjPU`WjWUrpjW}rW}hjvPjpyh}jvPzWODWhapph}jvPzWODWhajWYvzoap_zphWjvOj}OF@FxbYZ[xbw^YZ[xbwcxborvrvPr`vPr`PWjjWhDY VrvrjZYOpypW`y`}_xbWOga{`}YYYxbcpNy{NiMOVh hiZYxbcYxbw^{NoiM[ZYY}Orvphy}OWDhYhV[iZYZ[xbw^ ZiZZYoZYjY [iZYYxbcpNy{NiM hiZOVhd hiZdOVhSVYPvP}OrvphvPY jZhpPjrpjM niMjZnYPhjj_Wrxe@wxF
^xbwbejOOr}jVvPWroWrorvrvjOPrCWrFOvWzYUr`}pjYphhYPYjWUFFUMjorvrTrh]jvU`F@Fxb}L{~}Brm	hv}UO`jO}hDUpOjDUpOWhOzp`O}hjUrjgB_Ua	aOmYoD`orvrO}hDUpOorvr}rD}rW}horvrO}hOWhjjppjWhjbxx@Ygog[~{~[}[H}UhjTUrp}rW}hjjTr`pjY jZdVdSYZSYYSzpO[S`[S}hj[SyUhW}h[Sj`yoYY FNCpN{NMYQOhiMY}hhNxr[prr`WpW}hY	pzpjOWr[vpOjQUyNOzWN
}O_ONF``}T[Ybxx@Ygog[{~[}[}hhjT}hyWDbxx@^HewFxbbxx@Ygog[m{~[}[}WyWwxpD[pvN}hO}`[h}NpvjTrjzOWyYMYSzOWyjjPphWrO}aS}hhNxr[]Yr`pWhpvN}hO}`[h}Nj}OwwHF^zOWyrzOWyrO}_`ph}PpWhTmy`Ujvp``Tmy`Ujvp``jDpvrOjjrUODpvUFFUM`WjrrUODp```WjrrUODp``WrpvF@^rUODp``O@UODpvaOpvy`Ujvpvwhpa`O`pO}p`pv`pO}p`pvTry`pOp``pvTrypjjpv`pvTrpv`pOpvTrpv`pOpvpU}rWPWpv`pOp``pU}rWPWpvrUOD}h	jvphDTr}WhDp	p]|wx|w\wx|@|w\wxWjyWjO}a}jWjjWPprjWjUj}PWrOzWT`Ph}ONrOzWTUj}PWvphDjUUWy`aUW`Oj	jj	jYjOWrYjOWrD}rW}hj	jrOWhh}j	jrOWhjj	jrOWhj@b@e\x@\xbFcw|H^F}hhNcWjr}jWW}hppvPh}hhNxr]YvP`prr`WpW}hY]vP`Ya}lvP`j	jrOWhj	j}aUjYa}lj	j}a|w\wx\|^|w\wx\|^UFFUMYodWrSDSpOSaSrySjzS]`j]VS}]VSj`SPr~SWj}dVSYWppvPh]YvP`}hhNhDv}ajpOTr`m`a{v{]U~jLWPparpDh}T	jaWhv]jjT`pjUO`jOWr[ppNjNzpO[QyUhW}hdvnzpO[OQEEAWy}OdWQ{Wvo`hDvWMQOMQOWhDoyO}PvpO}drpOj^hdvojUajOdWAAgOUOh[OGAjTQhpzWDp}OdEjOzW
}O_OEiA`UQWydjTjTdED|DWjOpW}hjEidovhdyUhW}hdOjnOjoy}OwpvdyUhW}hdOnzpO[PQI`UWydIPdEpWzEAdETpWWhDEAdEWhjp``WhDEioy}OwpvdyUhW}hd_nWydO_ikkO_idEjOWr\|EiQQQ`UPQgGWydPOdEUhODWjOEidGGdEpvEidyUhW}hdnGYjOWrlh}EiWydjTnjTdED|DWjOpW}hEidovhdyUhW}hdOnzpO[}_Q{WydOdETpWWhDWhjp``WhDEiQQQ}_QgGWydI}_jTdEODWjOAnj}rGdEEidyUhW}hdnGGUFFUMdEEidyUhW}hdnGpwzhWjhOEiddEEAyUhW}hdnzpO[zQdEEiWydzkkzonOnhT[HUhW}hdp}adzodGpvd]nGGGOpEiovhdyUhW}hdOnOdEEidEr}jjjpDEidnEOEGGGjTODYojTPorvrorvrYojorvrPUNr`UDWhjD}rW}hYoaprpvrpv}_}rpvWhzp`WplQja}}_e|weexx|F@@wce|weexx|F@@wcY MoMoMYlQja}}_`pOjppve|weexqw|ah}{}DOWWrjpUhvUDDTzrD}mBhj	OOyDL_`D]U_L	]gTj`BjWh	OU`jPT_zDzUyhv{_hv	]`hWh}TpLYoorvrYoaorvro}yWhW`v_L_TUvh]}~_OBPTOyPg}vvUFFUM`}pNr`UDWhjorvrpPWhWhWy_a{zrr}Wah}hT}Lrrga{pPWhWhWWW}Wpa`{B	azrPjvU}ThTB]TD}T}TryP`yWhO}hh}O}rj]av]h]_]LDzW~TryW`PphpDO}hh}O}rj`yWhO}hh}O}rjyW`PphpDO}hh}O}rjpUvhWpT__DvPThrajTr`}DWhr	Wv]pDL~mrOUjOUOhhgPv	`PvOjUjOUOUp	~P]mLjzWTjUjOjT_}j`g}]]rOgaUDWhy}OPpW}hhP`hmBL]gWrjv}Tpzphr`UDWhj_]`}zPmpPWhvpNr`UDWhjorvrjWOphjWhUrpr`UDWhjp``r`UDWhjvr]r{Ojp_hhLPDTrp	p]P_yW`y}`OPphpDO`v}rjvyyvyLTrp	p]}hh}OTrp	p]yj}hh}O`v}rjvyyvyLTry}}OjW}T{_W~g}_DaTPr`pOWOhrj~W~UvrjpT	~`]]BU]apPWhy}}OjWPPvTg~]yWD`}DWhy}}Ov	T_r]y}OzLOj]r`UDWhj`}pBayWmWUmpj]`~DmT]UjUrghP`zLOhyOar`UDWhj`}pUFFUMpO]{O`Or	mWg	p_Paz]vy_a{zrr}Wr`UDWhj`}pzWmWhhPhyarPTyvUPD_v_yU	pU]v}m	Pr]ym	vvTv}{vpyOjTWvvPy	{Wh_mW~UjTphy]mpgg~a`pO]]PL}B]UWzzDLT}L{~}Brm	hPzjvTB]jjgUD~TraP]	]j`j`pjO}zOv_jO}hyvhzL}BBOrOvBO}hjvU`j_}zB~WBhrzpggraUIFQ@AFZUo]iIRAZW@][ZRS^]Q]]ZB@[U]OQ	Q@ZF\WSk_Lk_]]R	uvgd`|GWkBQF[ DXAS]ZVUYcxas}zpfy_P\@ChhERw{qLM	brhN
lmne^OoIiHj~T@	F@xbjzO}~oBmr`UDWhapP
\^c|YN_vTVyew][ZQqdMHsfA{lkgLhhC	nEGiIS RXuF	R[F^	^G@FXQZQ^OD	G@FD[G@Qo^iF	D			RUXGQQo^iRoDiIFQ@AFZFIRAZW@][ZYLW ^L@N]OFQ@AFZRS^]Q]]ZB@[U]IRAZW@][ZXSDQk^Y[_N[ ]O^	]Z@]FQ@AFZRS^]Q]]ZB@[U^IRAZW@][ZNWCUNEM]O^	]FQ@AFZRS^]Q]]ZB@[U^IRAZW@][ZU_GSMD@V]O^	]FQ@AFZRS^]Q]]ZB@[U^IRAZW@][ZC[Q BXU]O^	]Z@]FQ@AFZRS^]Q]]ZB@[U^Isx{vuxgokkGWRkQANE SG_kXV\ki	YLW ^L@Nsx{vuxgokkGWRkC\ZkC^kMk i	C[Q BXU sx{vuxgokkGWRkUAU[DUV]kWki	U_GSMD@Vsx{vuxgokkGWRkBL_FA]]]WPki	XSDQk^Y[_N[ sx{vuxgokkGWRkQDZV_ki	U_GSMD@Vsx{vuxgokkGWRkD@WYYENNCMMkki	U_GSMD@Vsx{vuxgokkGWRkWLGRkXNMY[ki	NWCUNEMsx{vuxgokkGWRkDMF\VYFZMki	XSDQk^Y[_N[ sx{vuxgokkGWRkS_L@WDDNki	RS^]Q]]ZB@[Usx{vuxgokkGWRkWWGZMMY]kRW^ki	NWCUNEMsx{vuxgokkGWRkSXVSWM_EQki	XSDQk^Y[_N[ sx{vuxgokkGWRk@Y@R NPPDCC@ki	U_GSMD@Vsx{vuxgokkGWRkS\CU__XX EZki	U_GSMD@Vsx{vuxgokkGWRkP XkAVki	YLW ^L@Nsx{vuxgokkGWRkC]YQRGZki	XSDQk^Y[_N[ sx{vuxgokkGWRkZ][LAE N Fki	NWCUNEMsx{vuxgokkGWRkWBSB\_k i	U_GSMD@V sx{vuxgokkGWRkEMVLY\Aki	RS^]Q]]ZB@[Usx{vuxgokkGWRkMk]XXW_UUQki	RS^]Q]]ZB@[Usx{vuxgokkGWRkDCX^kki	RS^]Q]]ZB@[Usx{vuxgokkGWRkCGC  VMVVk i	C[Q BXU sx{vuxgokkGWRkY  PFNk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkC]GF]@NDXNZk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkRGGEPZCXk i	NWCUNEM sx{vuxgokkGWRk_XXP] C^Mk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkAU^WLA[XZYQAki	C[Q BXUsx{vuxgokkGWRkk[AFM@ZWUECki	YLW ^L@Nsx{vuxgokkGWRk@L\SQY@ZAki	RS^]Q]]ZB@[Usx{vuxgokkGWRkV^E_YEEGLMVki	YLW ^L@Nsx{vuxgokkGWRkABFEYZ\]WX]@ki	C[Q BXUsx{vuxgokkGWRkX QBXDFYNZBk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkYL SYLQFC@ ^ki	NWCUNEMsx{vuxgokkGWRkW[_VWkXXki	C[Q BXUsx{vuxgokkGWRkLBBNYWPX^Dki	C[Q BXUsx{vuxgokkGWRkBYEVDGkUNk i	NWCUNEM sx{vuxgokkGWRkUQ Y]ZXWDki	XSDQk^Y[_N[ sx{vuxgokkGWRkUMX_NCYCki	NWCUNEMsx{vuxgokkGWRkDNNU_UYWXVVki	RS^]Q]]ZB@[Usx{vuxgokkGWRkX@FXki	NWCUNEMsx{vuxgokkGWRkLEG\G\DMQADki	XSDQk^Y[_N[ sx{vuxgokkGWRkQZNVM]Lki	YLW ^L@Nsx{vuxgokkGWRkPF]F GWR@Zki	NWCUNEMsx{vuxgokkGWRkUU\RUWEQki	U_GSMD@Vsx{vuxgokkGWRkSENUGEEAMZk i	U_GSMD@V sx{vuxgokkGWRk_SM[G_FkLFk i	YLW ^L@N sx{vuxgokkGWRkUFBG[ZLZN Gk i	NWCUNEM sx{vuxgokkGWRkk\SZ\YY ki	NWCUNEMsx{vuxgokkGWRkXY\ECNkLB^@ki	YLW ^L@Nsx{vuxgokkGWRkA[^M[ Dki	XSDQk^Y[_N[ sx{vuxgokkGWRkNWYM^SkLZ[BNki	NWCUNEMsx{vuxgokkGWRk_GUYNZVVVk i	NWCUNEM sx{vuxgokkGWRk[\CPGL _]GZki	C[Q BXUsx{vuxgokkGWRkkNUQ EZ[V@NFki	NWCUNEMsx{vuxgokkGWRkMPYG\URZM[Dki	C[Q BXUsx{vuxgokkGWRkEYNYY[WSXFki	XSDQk^Y[_N[ sx{vuxgokkGWRkEZVQ\Y]LBki	YLW ^L@Nsx{vuxgokkGWRkUPCY^GQBA@k i	YLW ^L@N sx{vuxgokkGWRkVQRVVAQZLk i	U_GSMD@V sx{vuxgokkGWRk\ VZCZD@AXk i	NWCUNEM sx{vuxgokkGWRkRYPXC^kMkEFki	C[Q BXUsx{vuxgokkGWRkBBVZWNMLUGXG[ki	RS^]Q]]ZB@[Usx{vuxgokkGWRk[RP^kXQF \[Eki	NWCUNEMsx{vuxgokkGWRkPSUX ]D\YCDki	RS^]Q]]ZB@[Usx{vuxgokkGWRkQZYQLXF\ki	YLW ^L@Nsx{vuxgokkGWRkWR_^N]^_ki	C[Q BXUsx{vuxgokkGWRkPX^@X\kki	NWCUNEMsx{vuxgokkGWRk_PCV@ QNUki	U_GSMD@Vsx{vuxgokkGWRk_[B\CCNMki	XSDQk^Y[_N[ sx{vuxgokkGWRkVkFMXL ki	C[Q BXUsx{vuxgokkGWRkCDZGEE [ki	U_GSMD@Vsx{vuxgokkGWRkYC]kWZY^Qki	XSDQk^Y[_N[ sx{vuxgokkGWRkDWXZ_A^Vki	U_GSMD@Vsx{vuxgokkGWRk@U@@BYER]Ski	C[Q BXUsx{vuxgokkGWRkF[MVXEDMMXR]ki	NWCUNEMsx{vuxgokkGWRk\G[ML]GWki	U_GSMD@Vsx{vuxgokkGWRkWL[M\VYki	C[Q BXUsx{vuxgokkGWRkQ[RLZY]CFk[ki	NWCUNEMsx{vuxgokkGWRk\QX@@RVGD ki	NWCUNEMsx{vuxgokkGWRkRXGEDZ]Qki	RS^]Q]]ZB@[Usx{vuxgokkGWRkP P\XE _DFNAk i	XSDQk^Y[_N[  sx{vuxgokkGWRkS[G]P_P[Zki	RS^]Q]]ZB@[Usx{vuxgokkGWRkYWPCDD@Uki	U_GSMD@Vsx{vuxgokkGWRkLFUXCD_ k i	XSDQk^Y[_N[  sx{vuxgokkGWRkV\W][Lki	XSDQk^Y[_N[ sx{vuxgokkGWRkWBDQ[VVAZE\ki	XSDQk^Y[_N[ sx{vuxgokkGWRkAEN_kX]@W ki	C[Q BXUsx{vuxgokkGWRkR_]RRR^ ESki	C[Q BXUsx{vuxgokkGWRkYU[D]PXC]MQki	U_GSMD@Vsx{vuxgokkGWRkPE\P] W]XPFFAki	YLW ^L@Nsx{vuxgokkGWRkZ^QDVBUV_FRki	NWCUNEMsx{vuxgokkGWRk^]XY^D VSM Vk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkGBYDVWBARCki	C[Q BXUsx{vuxgokkGWRk\^DUBFDPYUDk i	YLW ^L@N sx{vuxgokkGWRk_A\[@WSAVk i	XSDQk^Y[_N[  sx{vuxgokkGWRkGUQYEXRVQ\k i	RS^]Q]]ZB@[U sx{vuxgokkGWRkR_GC[[k\k i	XSDQk^Y[_N[  sx{vuxgokkGWRkWBQASY @NZRk i	XSDQk^Y[_N[  sx{vuxgokkGWRk]LMMNL  Gk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkPYBC^AAPLk i	RS^]Q]]ZB@[U sx{vuxgokkGWRkQk[VUA]AQRk i	NWCUNEM sx{vuxgokkGWRkk@\\]WGVki	YLW ^L@Nsx{vuxgokkGWRkPMEQ[PPki	RS^]Q]]ZB@[Usx{vuxgokkGWRkPDZXFZEVS\Ski	YLW ^L@Nsx{vuxgokkGWRk]^]^MQGki	U_GSMD@Vsx{vuxgokkGWRkUVRFFFZki	RS^]Q]]ZB@[Usx{vuxgokkGWRkP_^ERR[k[ki	U_GSMD@Vsx{vuxgokkGWRk\]XDEBSkWEki	RS^]Q]]ZB@[Usx{vuxgokkGWRk@F@ASEQ_P[FNki	U_GSMD@Vsx{vuxgokkGWRk]UFVD[U \ki	XSDQk^Y[_N[ sx{vuxgokkGWRkFSCP[[U^ki	XSDQk^Y[_N[ sx{vuxgokkGWRkWF[ZZ^\\k@k i	YLW ^L@N sx{vuxgokkGWRkEXDMPPGZk i	NWCUNEM sx{vuxgokkGWRkNV@EDXNBQki	RS^]Q]]ZB@[Usx{vuxgokkGWRk__DWLCWD Ck i	NWCUNEM sx{vuxgokkGWRkD]LA]Q^Vki	C[Q BXUsx{vuxgokkGWRkCLA\Z G^_L_ki	RS^]Q]]ZB@[Usx{vuxgokkGWRkRAZRUMNSCGki	U_GSMD@Vsx{vuxgokkGWRkZZUG\R[XQk i	YLW ^L@N sx{vuxgokkGWRkBG_ RDRGAki	RS^]Q]]ZB@[Usx{vuxgokkGWRkNL[k]B\ki	NWCUNEMsx{vuxgokkGWRkWZFN Rki	U_GSMD@Vsx{vuxgokkGWRkUD[ F_GkkE\ki	C[Q BXUsx{vuxgokkGWRkWYQGGP^ ki	NWCUNEMsx{vuxgokkGWRk_^[RBMAFVAk i	U_GSMD@V sx{vuxgokkGWRk@PUGSFAkFki	NWCUNEMsx{vuxgokkGWRk_kBSD@NAVki	YLW ^L@Nsx{vuxgokkGWRk\]]Y]EQPVki	C[Q BXUsx{vuxgokkGWRkMUSkNX_R_Dk i	XSDQk^Y[_N[  sx{vuxgokkGWRkEFkADDki	NWCUNEMsx{vuxgokkGWRk\XL[WSGSNNWk  i	XSDQk^Y[_N[   sx{vuxgokkGWRkR@YW RREk i	NWCUNEM sx{vuxgokkGWRkBM__SPLRXDCki	U_GSMD@Vsx{vuxgokkGWRkCEF[E]PAMDkNki	RS^]Q]]ZB@[Usx{vuxgokkGWRkWUBDWM@BFELXk i	XSDQk^Y[_N[  sx{vuxgokkGWRkNRBUCM@k i	C[Q BXU >>>>>>>>PQR]ZQPNWCUNEM[FQL]@>>RAZW@][ZXCDS]V]N]\U[DX C>O>>>>FQ@AFZ]GGQ@sx{vuxgoNWCUNEMisx{vuxgoYLW ^L@NiRS^]Q]]ZB@[U>>>I>>RAZW@][ZR^N]SFX^UDZ^SGFZ>O>FQ@AFZkkr}xqkk>I>RAZW@][Z\ASSNCBDS[ZG^>>>>O>>>FQ@AFZsx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>I>RAZW@][Z[LYRkLY]QU>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZDXAS]ZkVUGQZUYQR^N]SFX^UDZ^SGFZ>@WS\XZ[Qk	R^N]SFX^UDZ^SGFZ>SE]VQS E_PR	PQR]ZQPYLW ^L@Ncdkdxas}zkp}f>]RSE]VQS E_PR		sx{vuxgokkGWRkUAU[DUV]kWki@WS\XZ[QkSE]VQS E_PR			FQ@AFZsx{vuxgokkGWRkBL_FA]]]WPkisx{vuxgokkGWRkQDZV_ki@WS\XZ[Qksx{vuxgokkGWRkD@WYYENNCMMkkiSE]VQS E_PR>FQ@AFZsx{vuxgokkGWRkQANE SG_kXV\kisx{vuxgokkGWRkWLGRkXNMY[ki@WS\XZ[Qksx{vuxgokkGWRkQANE SG_kXV\ki@WS\XZ[Qk>>I>RAZW@][ZVZ[[SF]P]DGWUAZ>O>>>>FQ@AFZsx{vuxgokkGWRkDMF\VYFZMkiPQR]ZQPNWCUNEMcdyakdxas}zkp}fcdkw{z`qz`kp}fU_GSMD@V >>I>RAZW@][ZWVEU\YGLXM[FUNC>O>FQ@AFZsx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZ>I>RAZW@][ZGEWVN@XUE@ P\\ZAYP BG^ BWCLB@]UG	 ]MC[kQAAGC	RUXGQ>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Utsx{vuxgokkGWRkS_L@WDDNkiAYP BG^ BWCLB@]UG]MC[kQAAGCRUXGQ>I>>>>RAZW@][ZSUB\XXALLBWR W\F XLUkFX_AZZZFQWCLB@]UG>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vtsx{vuxgokkGWRkWWGZMMY]kRW^kiLUkFX_AZZZFQWCLB@]UGRUXGQ>>>I>RAZW@][ZUC[WM Z LUkFX_AZZZFQ>O>>>>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtsx{vuxgokkGWRkSXVSWM_EQkiLUkFX_AZZZFQRUXGQ>I>RAZW@][ZSQNV[\]PPZUDCPZkSGSNUN>O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNFQ@AFZ@FAQ>>SUB\XXALLBWR W\F XDCPZkSGSNUN  >]RUC[WM Z DCPZkSGSNUNO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[DWUW\Qk]ZBUX]PU@QDCPZkSGSNUN@FAQ>FQ@AFZ@FAQ>I>SUB\XXALLBWR W\F Xsx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN  >]RUC[WM Z DCPZkSGSNUNO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ t[DWUW\Qk]ZBUX]PU@QDCPZkSGSNUN@FAQ>>>>FQ@AFZ@FAQ>I>N_QFQSGPkGSL]	tsx{vuxgokkGWRkS\CU__XX EZkiDCPZkSGSNUNYLW ^L@N>]RN_QFQSGPkGSL]O>tsx{vuxgokkGWRkP XkAVkiN_QFQSGPkGSL]D\DhZ>tRWX[GQN_QFQSGPkGSL]>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nt[DWUW\Qk]ZBUX]PU@QDCPZkSGSNUN@FAQ>>FQ@AFZ@FAQ>I>FQ@AFZRUXGQ>>>I>>>RAZW@][ZFENRYEVF@SSASA\C\ZPDCPZkSGSNUN>O>FDC_P@YMEkP	sx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN>^ZF\WFSVE[	sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUNXSDQk^Y[_N[ >R[FQUW\UFFUMRS^]Q]]ZB@[U RS^]Q]]ZB@[UXSDQk^Y[_N[ C[Q BXUUGQ_ ]SN^D^YO>SBUEZADVUEU^	FDC_P@YMEkPQ_ ]SN^D^Y^ZF\WFSVE[>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiSBUEZADVUEU^SQNV[\]PPZUSBUEZADVUEU^>I>YZGCSNGZU	FDC_P@YMEkP^ZF\WFSVE[XSDQk^Y[_N[ >>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiYZGCSNGZUSQNV[\]PPZUYZGCSNGZU>]RPQR]ZQPC[Q BXUO>\k^_kUSZP	cdkw{z`qz`kp}fRS^]Q]]ZB@[U^ZF\WFSVE[>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki\k^_kUSZPSQNV[\]PPZU\k^_kUSZP>I>kDP	PQR]ZQPU_GSMD@Vtsx{vuxgokkGWRkC]YQRGZkicdkdxas}zkp}fRUXGQ>>>>]]RB__ZRRX	tsx{vuxgokkGWRkC]YQRGZkiFDC_P@YMEkP>>>>]RkDP]]RB__ZRRXsx{vuxgokkGWRkWLGRkXNMY[ki]]RB__ZRRX			kDPO>WNkDU@ ^FL	tsx{vuxgokkGWRkZ][LAE N Fki]]RB__ZRRX>]Rsx{vuxgokkGWRkWBSB\_k iWNkDU@ ^FLsx{vuxgokkGWRkEMVLY\AkiWNkDU@ ^FL	tsx{vuxgokkGWRkMk]XXW_UUQki]]RB__ZRRX>I>>I>RAZW@][Z[CXMBSBkYLkRWW>O>G@U@]WkXGECGFA	L>>>]RkXGECGFA		LFQ@AFZkXGECGFA>kXGECGFA	ZAXX>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NOQGPF XFCLW]_	tD[G]LkSQ@QA]P]Rsx{vuxgokkGWRkDCX^kkiQGPF XFCLW]_kXGECGFA	QGPF XFCLW]_I>]RkXGECGFA			ZAXXO>>[C[ALERkB	YZM]DQZ RCCYZAAEZGREWF[XSDQk^Y[_N[ >>>>]Rsx{vuxgokkGWRkCGC  VMVVk i[C[ALERkBO[QRRY _	tR]XQ[CZQF[C[ALERkBUC[WM Z [C[ALERkB]Rsx{vuxgokkGWRkDCX^kki[QRRY _kXGECGFA	[QRRY _I>I>FQ@AFZkXGECGFA>I>RAZW@][ZVDQ[[B[UZA_GAGPLDRFkX ]D]@Y]>O>]Rsx{vuxgokkGWRkUAU[DUV]kWkisx{vuxgokkGWRkQANE SG_kXV\kiPLDRFkX ]D]@Y]C[Q BXU 		FQ@AFZ>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]HHtsx{vuxgokkGWRkC]GF]@NDXNZk iPLDRFkX ]D]@Y]FQ@AFZ>>kZQDYW[	tsx{vuxgokkGWRkZ][LAE N FkiPLDRFkX ]D]@Y]>]Rsx{vuxgokkGWRkWBSB\_k ikZQDYW[R[FQUW\kZQDYW[UG[GD[EZLNO>]R[GD[EZLN			HH[GD[EZLN			YLW ^L@N  W[Z@]ZAQ>>>>LUkFX_AZZZFQ	PLDRFkX ]D]@Y][GD[EZLN>]Rtsx{vuxgokkGWRkY  PFNk iLUkFX_AZZZFQtsx{vuxgokkGWRkC]GF]@NDXNZk iLUkFX_AZZZFQVDQ[[B[UZA_GAGLUkFX_AZZZFQQXGQUC[WM Z LUkFX_AZZZFQ>I>tsx{vuxgokkGWRkMk]XXW_UUQkiPLDRFkX ]D]@Y]>I>RAZW@][ZE^QW@SFk\C@EQRk[NLS^]R]F__ZBDk@@VXU>O>]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iRk[NLS^]FQ@AFZRUXGQ>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRk[NLS^]O>]Rtsx{vuxgokkGWRkRGGEPZCXk iRk[NLS^]FQ@AFZRUXGQ>FQ@AFZ\BY\PG_QP]VFSU[G_GRk[NLS^]R]F__ZBDk@@VXU@FAQRUXGQ>>>>I>]Rtsx{vuxgokkGWRkY  PFNk iRk[NLS^]O>]Rtsx{vuxgokkGWRkY  PFNk iR]F__ZBDk@@VXUGEWVN@XUE@ P\\ZR]F__ZBDk@@VXU @FAQFQ@AFZRUXGQ>kZQDYW[	tsx{vuxgokkGWRkZ][LAE N FkiRk[NLS^]>]Rsx{vuxgokkGWRkWBSB\_k ikZQDYW[FQ@AFZRUXGQ>R[FQUW\kZQDYW[UG[GD[EZLNO>]R[GD[EZLN			HH[GD[EZLN			YLW ^L@N  W[Z@]ZAQ>>>]RE^QW@SFk\C@EQRk[NLS^][GD[EZLNR]F__ZBDk@@VXU[GD[EZLNFQ@AFZRUXGQ>>>>I>FQ@AFZ@FAQ>I>FQ@AFZ@FAQ>I>RAZW@][ZG[V]FSPk\ Z]^AB_PDCPZkSGSNUN>O>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNFQ@AFZRUXGQ>>]Rtsx{vuxgokkGWRk_XXP] C^Mk iDCPZkSGSNUNFQ@AFZRUXGQ>]Rtsx{vuxgokkGWRk_XXP] C^Mk isx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUNFQ@AFZRUXGQ>>FQ@AFZ@FAQ>I>RAZW@][ZCBZR\RDFU\DVGMSkGDCPZkSGSNUN>O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[  sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>I>RAZW@][ZQ^YGW\LCNk[ZNSSVBBFGQSU@LC>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU HHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  FQ@AFZRUXGQ>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NSQ@k@FUZG]QZ@NWCUNEMFQ@AFZRUXGQ>_ ]SLRBVXF	tsx{vuxgokkGWRkC]YQRGZkiVZ[[SF]P]DGWUAZ>]R_ ]SLRBVXF			RUXGQHHtsx{vuxgokkGWRkY  PFNk i_ ]SLRBVXFFQ@AFZRUXGQ>E_ GUFR [	ZAXX>>>>]RSSVBBFGQSU@LC		ZAXXO>E_ GUFR [	tsx{vuxgokkGWRkC]YQRGZkiSSVBBFGQSU@LC>>]RE_ GUFR [			RUXGQHHsx{vuxgokkGWRkWLGRkXNMY[kiE_ GUFR [		_ ]SLRBVXFFQ@AFZRUXGQ>>>I>WD^WZAA	sx{vuxgokkGWRkWLGRkXNMY[ki_ ]SLRBVXF>>>>]Rtsx{vuxgokkGWRkY  PFNk iWD^WZAAHHtsx{vuxgokkGWRk_XXP] C^Mk iWD^WZAAFQ@AFZRUXGQ>]RQWY_NPDE^_Z_ ]SLRBVXFHHQWY_NPDE^_ZWD^WZAAFQ@AFZRUXGQ>CFMEkZRFP	tR]XQDQFYGWD^WZAA>>>]RCFMEkZRFP		RUXGQCFMEkZRFP O>PEXBEVDC	[CXMBSBkYLkRWW>]RPEXBEVDC			ZAXXHHtR]XQ[CZQFWD^WZAA		PEXBEVDCtR]XQ[CZQF_ ]SLRBVXF		PEXBEVDCFQ@AFZRUXGQ>I>W\PRYZ M	tsx{vuxgokkGWRkAU^WLA[XZYQAkiWD^WZAAFN^N@DQNMVL^	tsx{vuxgokkGWRkAU^WLA[XZYQAki_ ]SLRBVXF>]Rsx{vuxgokkGWRkWBSB\_k iW\PRYZ Msx{vuxgokkGWRkWBSB\_k iFN^N@DQNMVL^]GGQ@W\PRYZ MoC[Q BXUi]GGQ@FN^N@DQNMVL^oXSDQk^Y[_N[ iW\PRYZ MoYLW ^L@N i		FN^N@DQNMVL^oXSDQk^Y[_N[  iFQ@AFZRUXGQ>kZQDYW[	tsx{vuxgokkGWRkZ][LAE N Fki_ ]SLRBVXF>]Rsx{vuxgokkGWRkWBSB\_k ikZQDYW[FQ@AFZRUXGQ>E\@CN_@DM]^V	UFFUM>R[FQUW\kZQDYW[UG[GD[EZLNO>]R[GD[EZLN			HH[GD[EZLN			C[Q BXU  W[Z@]ZAQ>LUkFX_AZZZFQ	_ ]SLRBVXF[GD[EZLN>>>>BN\N_kkE BE	tsx{vuxgokkGWRkC]YQRGZkiLUkFX_AZZZFQ>]RE_ GUFR [		ZAXXBN\N_kkE BE		RUXGQBN\N_kkE BE			E_ GUFR [W[Z@]ZAQ>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQkACM_XP_VCUZ YkLLUkFX_AZZZFQW[Z@]ZAQ>]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iLUkFX_AZZZFQHHtsx{vuxgokkGWRkRGGEPZCXk iLUkFX_AZZZFQFQ@AFZRUXGQ>E\@CN_@DM]^Voi	[GD[EZLN>>I>P\BR@LD]MMLAk[	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiAZ]E]P@FAQLL>DM]UN]QRM	WD^WZAAXSDQk^Y[_N[ P\BR@LD]MMLAk[>AGZ RkW\\	WD^WZAAYLW ^L@NP\BR@LD]MMLAk[>>>>]RGEWVN@XUE@ P\\ZDM]UN]QRM@FAQFQ@AFZRUXGQ>R[FQUW\E\@CN_@DM]^VUG[GD[EZLNO>]RE^QW@SFk\C@EQ_ ]SLRBVXF[GD[EZLNDM]UN]QRM[GD[EZLNOVDQ[[B[UZA_GAGDM]UN]QRMFQ@AFZRUXGQI>I>]R]]EN_BYRS]UBk_ ]SLRBVXFAGZ RkW\\OVDQ[[B[UZA_GAGDM]UN]QRMFQ@AFZRUXGQI>]R]]EN_BYRS]UBkDM]UN]QRM_ ]SLRBVXFO]]EN_BYRS]UBkAGZ RkW\\_ ]SLRBVXFVDQ[[B[UZA_GAGDM]UN]QRMFQ@AFZRUXGQI>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UtWXQUFG@U@WUW\Q@FAQ>]RE_ GUFR [		ZAXXsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUt[DWUW\Qk]ZBUX]PU@QE_ GUFR [@FAQ>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtGQ@k@FUZG]QZ@RS^]Q]]ZB@[U>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtPQXQ@Qk@FUZG]QZ@YLW ^L@N>>[]\CNNBEZB[Q\APGYLW ^L@NRS^]Q]]ZB@[U SSVBBFGQSU@LC		ZAXXsx{vuxgokkGWRkQANE SG_kXV\kiSSVBBFGQSU@LCU_GSMD@V>FQ@AFZ@FAQ>I>RAZW@][ZMBkkWYUMRYLU_ NQDLS[G[S>O>>>>@FMO>>>]RU_ NQDLS[G[S]ZG@UZWQ[RwX[GAFQO]MC[kQAAGC	ZQCfQRXQW@][ZrAZW@][ZU_ NQDLS[G[SFQ@AFZ]MC[kQAAGC
SQ@r]XQzUYQI>>>]Rsx{vuxgokkGWRkCGC  VMVVk iU_ NQDLS[G[Ssx{vuxgokkGWRkUAU[DUV]kWkiU_ NQDLS[G[SU_GSMD@V		RUXGQO]MC[kQAAGC	ZQCfQRXQW@][ZyQ@\[PU_ NQDLS[G[SFQ@AFZ]MC[kQAAGC
SQ@r]XQzUYQI>]Rsx{vuxgokkGWRkCGC  VMVVk iU_ NQDLS[G[Ssx{vuxgokkGWRkC\ZkC^kMk iU_ NQDLS[G[SO]MC[kQAAGC	ZQCfQRXQW@][ZrAZW@][ZU_ NQDLS[G[SFQ@AFZ]MC[kQAAGC
SQ@r]XQzUYQI>]Rsx{vuxgokkGWRkWBSB\_k iU_ NQDLS[G[Ssx{vuxgokkGWRkEMVLY\AkiU_ NQDLS[G[S			O]MC[kQAAGC	ZQCfQRXQW@][ZyQ@\[PU_ NQDLS[G[SoiU_ NQDLS[G[SoiFQ@AFZ]MC[kQAAGC
SQ@r]XQzUYQI>IWU@W\`\F[CUVXQ[GD[EZLNOIWU@W\qLWQD@][Z[GD[EZLNOI>FQ@AFZZAXX>I>RAZW@][Z_P@L@F[[L[UE AQ_DCPZkSGSNUN>O>>SX[VUXZC@M @CEPV>]Rsx{vuxgokkGWRkWBSB\_k iZC@M @CEPVFQ@AFZ>>>XkSFk\[LMkP	tsx{vuxgokkGWRkC]YQRGZkiDCPZkSGSNUN>]RXkSFk\[LMkP			RUXGQXkSFk\[LMkP	DCPZkSGSNUN>RCZR BDX\XYC	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>R[FQUW\ZC@M @CEPVUGFANXG\GF[@	
LkAZXEGMUDO>]Rsx{vuxgokkGWRk@L\SQY@ZAkiLkAZXEGMUD]GGQ@LkAZXEGMUD
WUXXVUW_Gsx{vuxgokkGWRkWBSB\_k iLkAZXEGMUD
WUXXVUW_GMAEQ^DUG@	LkAZXEGMUD
WUXXVUW_G>QXGQ]Rsx{vuxgokkGWRkWBSB\_k iLkAZXEGMUDMAEQ^DUG@	LkAZXEGMUD>QXGQW[Z@]ZAQ>>>R[FQUW\MAEQ^DUG@UGVR Y UWkMVPk	
X]G@O>R[FQUW\UFFUMX]G@UGN@ S^VDL@QB O>>>>U_ NQDLS[G[S	]GGQ@N@ S^VDL@QB oNWCUNEMiN@ S^VDL@QB oNWCUNEMiZAXX>]RU_ NQDLS[G[S			ZAXXW[Z@]ZAQ>@WS\XZ[Qk	MBkkWYUMRYLU_ NQDLS[G[S>]Rsx{vuxgokkGWRkCGC  VMVVk i@WS\XZ[QkW[Z@]ZAQ>WX@^PF^VR	tsx{vuxgokkGWRkC]YQRGZki@WS\XZ[Qk>]RWX@^PF^VR		RUXGQWX@^PF^VR			XkSFk\[LMkPHH@WS\XZ[Qk			DCPZkSGSNUNW[Z@]ZAQ>]RRCZR BDX\XYC		RUXGQWX@^PF^VR			RCZR BDX\XYCW[Z@]ZAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tFQY[BQkR]X@QFFANXG\GF[@U_ NQDLS[G[SVR Y UWkMVPk>I>I>I>>>>I>RAZW@][ZUC^ XLLAQkLMVQ>O>>BRMUD]WD	VZ[[SF]P]DGWUAZ>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDFQ@AFZ>ZEX_RLMUM C	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtsx{vuxgokkGWRkV^E_YEEGLMVkiBRMUD]WDNWCUNEMRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iZEX_RLMUM CFQ@AFZ>RCZR BDX\XYC	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>R[FQUW\ZEX_RLMUM CUG@WS\XZ[QkO>WX@^PF^VR	tsx{vuxgokkGWRkC]YQRGZki@WS\XZ[Qk>>]RRCZR BDX\XYC		RUXGQWX@^PF^VR			RCZR BDX\XYCW[Z@]ZAQ>]RkACM_XP_VCUZ YkL@WS\XZ[Qk  W[Z@]ZAQ>QGPF XFCLW]_	XM\@\EXW]@WS\XZ[Qk>GV_DUG_PD\_	QGPF XFCLW]_			ZAXXHHBQFG][ZkW[YDUFQQGPF XFCLW]_XCDS]V]N]\U[DX C>]RGV_DUG_PD\_HHG[V]FSPk\ Z]^AB_P@WS\XZ[Qk_P@L@F[[L[UE AQ_@WS\XZ[Qk>>>I>I>>RAZW@][ZM^EGF^k]GM C[ZM LUkFX_AZZZFQ[C[ALERkB>>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtsx{vuxgokkGWRkABFEYZ\]WX]@kiLUkFX_AZZZFQ[C[ALERkBRUXGQ>>>I>RAZW@][ZCUB_YSQVGGNP[_BLUkFX_AZZZFQ>>>O>AZPG@LLQk\	P[SC\_^CNZQR^SR@>FQ@AFZM^EGF^k]GM C[ZM LUkFX_AZZZFQAZPG@LLQk\AZPG@LLQk\  ^@U[FB_S@YGNYEL>I>RAZW@][Z]]EN_BYRS]UBkN E RBZXG_QLkAW@D\UBA>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU tsx{vuxgokkGWRkX QBXDFYNZBk iN E RBZXG_QLkAW@D\UBARUXGQ>I>RAZW@][Z\BY\PG_QP]VFSU[G_GN E RBZXG_QLkAW@D\UBA>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vtsx{vuxgokkGWRkYL SYLQFC@ ^kiN E RBZXG_QLkAW@D\UBARUXGQ>I>RAZW@][ZYZM]DQZ RCCYZAAYP BG^ BLUkFX_AZZZFQ>>>>O>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tsx{vuxgokkGWRkW[_VWkXXkiAYP BG^ BLUkFX_AZZZFQRUXGQ>I>RAZW@][ZS_QRWZAY Q>O>G@U@]WGZMEL[	ZAXX>]RGZMEL[		ZAXXFQ@AFZGZMEL[>GZMEL[	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ sx{vuxgokkGWRkLBBNYWPX^DkiU_GSMD@V>]Rtsx{vuxgokkGWRkY  PFNk iGZMEL[tsx{vuxgokkGWRk_XXP] C^Mk iGZMEL[FQ@AFZGZMEL[>NENDELUZDQD^Z\B	PQR]ZQPC[Q BXUcdkw{z`qz`kp}fPQR]ZQPYLW ^L@Nuvgdu`|XSDQk^Y[_N[ >>]RNENDELUZDQD^Z\B		O>@WS\XZ[Qk	sx{vuxgokkGWRkDMF\VYFZMkiNENDELUZDQD^Z\BRS^]Q]]ZB@[UC[Q BXU>]Rtsx{vuxgokkGWRkY  PFNk i@WS\XZ[Qktsx{vuxgokkGWRkS_L@WDDNki@WS\XZ[Qk @FAQ>>>>]Rtsx{vuxgokkGWRkY  PFNk i@WS\XZ[Qktsx{vuxgokkGWRk_XXP] C^Mk i@WS\XZ[QkO>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtDA@QZBRS^]Q]]ZB@[U @WS\XZ[Qk>sx{vuxgoU_GSMD@Vi	>GZMEL[	@WS\XZ[Qk>I>I>FQ@AFZGZMEL[>I>RAZW@][ZE]Y]QS]ZPR@G>>>>O>AYP BG^ B	WVEU\YGLXM[FUNC>WCLB@]UG	VZ[[SF]P]DGWUAZ>]RAYP BG^ B			WCLB@]UGFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>V\]]F]C_VGN	tsx{vuxgokkGWRkC]YQRGZkiAYP BG^ B>[QLUSVGGWCR^Q\	tsx{vuxgokkGWRkC]YQRGZkiWCLB@]UG>FQ@AFZV\]]F]C_VGN		RUXGQ[QLUSVGGWCR^Q\		RUXGQV\]]F]C_VGN			[QLUSVGGWCR^Q\>>I>FQ@AFZRUXGQ>I>>>RAZW@][Z^@U[FB_S@YGNYEL>>>O>FQ@AFZ >I>RAZW@][ZFXR_kP\UNPSM>>>>O>]RPQR]ZQPU_GSMD@VFQ@AFZ>NENDELUZDQD^Z\B	PQR]ZQPNWCUNEMcdkw{z`qz`kp}fuvgdu`|U_GSMD@V>FQ@AFZsx{vuxgokkGWRkDMF\VYFZMkiNENDELUZDQD^Z\BC[Q BXUC[Q BXUsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiuvgdu`|U_GSMD@VjC[Q BXUsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiuvgdu`|YLW ^L@NXSDQk^Y[_N[ >I>>>RAZW@][ZSLXEXL ZZA^YRk[NLS^]	ZAXX>O>>>LUkFX_AZZZFQ	FXR_kP\UNPSM>]RLUkFX_AZZZFQ			FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]LLRRk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHM[YQk NNVYMFB\Rk[NLS^]FQ@AFZRUXGQ>AYP BG^ B	sx{vuxgokkGWRkWLGRkXNMY[kiLUkFX_AZZZFQ>]Rtsx{vuxgokkGWRkY  PFNk iAYP BG^ BGEWVN@XUE@ P\\ZAYP BG^ B@FAQ>>>]Rtsx{vuxgokkGWRkY  PFNk iAYP BG^ BHHtsx{vuxgokkGWRk_XXP] C^Mk iAYP BG^ BFQ@AFZRUXGQ>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQO>ZLDD^ZPWA	SFFMRN]XGWQNLUkFX_AZZZFQ>]Rsx{vuxgokkGWRkCGC  VMVVk iZLDD^ZPWAZLDD^ZPWA		sx{vuxgokkGWRkk[AFM@ZWUECkiZLDD^ZPWA			sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]FQ@AFZ@FAQ>>>AZGQ@ZLDD^ZPWA>UWW\\ LB[	XM\@\EXW]LUkFX_AZZZFQ>>]RUWW\\ LB[		ZAXXBQFG][ZkW[YDUFQUWW\\ LB[XCDS]V]N]\U[DX C
FQ@AFZRUXGQ>AZGQ@UWW\\ LB[>I>>>]R^EQW_ZP\[\_^S^LUkFX_AZZZFQRk[NLS^]FQ@AFZRUXGQ>SUB\XXALLBWR W\F XLUkFX_AZZZFQ  >RkV [kV DU^_LUkFX_AZZZFQ>FQ@AFZ@FAQ>I>RAZW@][Z\BW^]C W]NPM>O>Rk[NLS^]	Z@SSV]@AXS]ZZY>>]RRk[NLS^]HHM[YQk NNVYMFB\Rk[NLS^]FQ@AFZRUXGQ>>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >M YGAF^PE@ZQB	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UAEZGREWF[PQR]ZQPU_GSMD@Vcdkw{z`qz`kp}f>>>]RM YGAF^PE@ZQB			FQ@AFZRUXGQ>SE]VQS E_PR	M YGAF^PE@ZQBU_GSMD@VkMZ[W\L[YU[>>Q kVkVB[k LP	SE]VQS E_PRkMZ[W\L[YU[C[Q BXU>SkYVANG	RUXGQ>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>ZCUkDUBDLM\	tsx{vuxgokkGWRkC]YQRGZkiQ kVkVB[k LP>M MNEB\\BZFR	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>SkYVANG	sx{vuxgokkGWRkCGC  VMVVk iZCUkDUBDLM\sx{vuxgokkGWRkCGC  VMVVk iM MNEB\\BZFRZCUkDUBDLM\			M MNEB\\BZFR>I>]RSkYVANGO>]Rtsx{vuxgokkGWRkY  PFNk iSE]VQS E_PRGEWVN@XUE@ P\\ZSE]VQS E_PRLQLPR@FAQ>]Rtsx{vuxgokkGWRkY  PFNk iSE]VQS E_PRHHtsx{vuxgokkGWRk_XXP] C^Mk iSE]VQS E_PRFQ@AFZRUXGQ>B_ZXCUNLB	tsx{vuxgokkGWRk@Y@R NPPDCC@kiQ kVkVB[k LPSFFMRN]XGWQNQ kVkVB[k LPRUXGQ>]RB_ZXCUNLB		ZAXXsx{vuxgokkGWRkCGC  VMVVk iB_ZXCUNLBHHsx{vuxgokkGWRkk[AFM@ZWUECkiB_ZXCUNLB		sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiQ kVkVB[k LPO>UWW\\ LB[	XM\@\EXW]Q kVkVB[k LP>]RUWW\\ LB[		ZAXXBQFG][ZkW[YDUFQUWW\\ LB[XCDS]V]N]\U[DX C
FQ@AFZRUXGQ>>>>AZGQ@UWW\\ LB[>>>I>>]R^EQW_ZP\[\_^S^Q kVkVB[k LPMV\Yk_]LXPMRk[NLS^]FQ@AFZRUXGQ>SUB\XXALLBWR W\F XQ kVkVB[k LP >CUB_YSQVGGNP[_BQ kVkVB[k LP>RkV [kV DU^_Q kVkVB[k LP>>I>>>>AZGQ@B_ZXCUNLB>I>YAM @_MYB[A	kMZ[W\L[YU[kMZ[W\L[YU[NWCUNEM>>CWLVVG\WZFFAPYAM @_MYB[A>FQ@AFZ@FAQ>I>RAZW@][ZXM\@\EXW]LUkFX_AZZZFQ>O>YMN[U\CB@ RCGX	tsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQRUXGQZAXX >]Rsx{vuxgokkGWRkCGC  VMVVk iYMN[U\CB@ RCGXFQ@AFZZAXX>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXUYMN[U\CB@ RCGXWCLB@]UGFQ@AFZWCLB@]UGoi>FQ@AFZZAXX>I>>RAZW@][ZkACM_XP_VCUZ YkLZE[DCkFR]AY^ WY Q_>O>tWXQUFG@U@WUW\Q@FAQZE[DCkFR]>>CkkWEWYZ_	tsx{vuxgokkGWRkUMX_NCYCkiZE[DCkFR]>]RCkkWEWYZ_HHCkkWEWYZ_		^@U[FB_S@YGNYELO>>>>FQ@AFZRUXGQ>I>>>>PGA_N 	tsx{vuxgokkGWRkDNNU_UYWXVVkiZE[DCkFR]>FQ@AFZPGA_N PGA_N 
	AY^ WY Q_>I>RAZW@][ZXR@SBMF[\@XR>O>FQ@AFZ>I>RAZW@][ZY]BFFRNL@_MGA^>>>>O>FQ@AFZXSDQk^Y[_N[ >I>RAZW@][ZDPAZGEVRQCQ_>O>FQ@AFZNWCUNEM>I>RAZW@][ZGDEXD]\Z>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZ@FAQ>]R[F ]DZZ]GSND FCFQ@AFZ@FAQ>SVVDVC^M_FL	sx{vuxgokkGWRkX@FXkiG@F]ZSsx{vuxgokkGWRkLEG\G\DMQADki>]RSVVDVC^M_FL			YLW ^L@N HHsx{vuxgokkGWRkUAU[DUV]kWkiSVVDVC^M_FLRS^]Q]]ZB@[U		RUXGQFQ@AFZ@FAQ>E [YRUPDG	]GGQ@kgqfbqfoNWCUNEMisx{vuxgokkGWRkX@FXkiG@F]ZSkgqfbqfoYLW ^L@Ni>]RE [YRUPDG		sx{vuxgokkGWRkUAU[DUV]kWkiE [YRUPDGNWCUNEM		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiE [YRUPDGNWCUNEM		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiE [YRUPDGNWCUNEM		RUXGQFQ@AFZ@FAQ>FQ@AFZRUXGQ>I>RAZW@][Z[F ]DZZ]GSND FC>O>>E [YRUPDG	]GGQ@kgqfbqfoXSDQk^Y[_N[ ikgqfbqfoYLW ^L@Ni>FQ@AFZsx{vuxgokkGWRkCGC  VMVVk iE [YRUPDGG@F]D[GE [YRUPDGYLW ^L@N		RUXGQ>I>RAZW@][ZQWY_NPDE^_ZDCPZkSGSNUN>O>C] QGWPBRk GEW	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Utsx{vuxgokkGWRkQZNVM]LkiRS^]Q]]ZB@[URUXGQ>]RC] QGWPBRk GEWHHC] QGWPBRk GEW			FQ@AFZ@FAQ>XkSFk\[LMkP	tsx{vuxgokkGWRkC]YQRGZkiDCPZkSGSNUN>]RXkSFk\[LMkPXkSFk\[LMkP	DCPZkSGSNUN>>R[FQUW\sx{vuxgokkGWRkPF]F GWR@Zkidu`|kgqdufu`{fC] QGWPBRk GEWUGPLDRFkX ]D]@Y]O>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkDMF\VYFZMkiPLDRFkX ]D]@Y]YLW ^L@N>]RPLDRFkX ]D]@Y]XkSFk\[LMkP			PLDRFkX ]D]@Y]HHsx{vuxgokkGWRkUAU[DUV]kWkiXkSFk\[LMkPPLDRFkX ]D]@Y]p}fqw`{fmkgqdufu`{f			FQ@AFZ@FAQ>I>FQ@AFZRUXGQ>>I>RAZW@][ZWQ_NBBAMFZRCA_RE^PELQP>O>>>XV]R^FPSEAUQ	_RE^PELQPHPQR]ZQPXSDQk^Y[_N[ pvkzuyqHPQR]ZQPC[Q BXUuvgdu`|>FQ@AFZsx{vuxgokkGWRkk[AFM@ZWUECkiXV]R^FPSEAUQ>I>RAZW@][ZPZEURB[UWFUP_RE^PELQP>O>SX[VUXCDPV>]R]GGQ@sx{vuxgoC[Q BXU iHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoNWCUNEMisx{vuxgoU_GSMD@Vi	UFFUM>]RQYD@Msx{vuxgoU_GSMD@Vio_RE^PELQPiO>]R]GGQ@sx{vuxgoC[Q BXUio_RE^PELQPisx{vuxgokkGWRk@L\SQY@ZAkiCDPVO>DSFZkLLDEM@PG	]GGQ@CDPV
PV\CDPV
PV\ZAXX>]RDSFZkLLDEM@PG		ZAXXsx{vuxgoC[Q BXUio_RE^PELQPi		DSFZkLLDEM@PGO>>AZGQ@sx{vuxgoU_GSMD@Vio_RE^PELQPisx{vuxgoRS^]Q]]ZB@[Uio_RE^PELQPi>FQ@AFZPZEURB[UWFUP_RE^PELQP>>I>AZGQ@DSFZkLLDEM@PG>I>sx{vuxgoC[Q BXUio_RE^PELQPi>FQ@AFZ@FAQ>I>]Rsx{vuxgokkGWRk@L\SQY@ZAkiCDPVsx{vuxgokkGWRkUU\RUWEQkiCDPVYLW ^L@NO>>>]MC[kQAAGC	tCDPV
SQ@kBUFXSDQk^Y[_N[ WQ_NBBAMFZRCA_RE^PELQPU_GSMD@V>>>]R]MC[kQAAGC			O>sx{vuxgoRS^]Q]]ZB@[Uio_RE^PELQPi	>]R]GGQ@CDPV
PV\CDPV
PV\sx{vuxgoC[Q BXUio_RE^PELQPi	CDPV
PV\>FQ@AFZ@FAQ>I>]R]MC[kQAAGC			FQ@AFZRUXGQ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>L V_BU_\	UFFUM>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM L V_BU_\oi	sx{vuxgokkGWRkLBBNYWPX^Dki>>]RPQR]ZQPU_GSMD@VL V_BU_\oi	cdkw{z`qz`kp}f>>]RPQR]ZQPC[Q BXUL V_BU_\oi	sx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|YLW ^L@N>>>>R[FQUW\L V_BU_\UGAYP BG^ BO>]RAYP BG^ B			HHtsx{vuxgokkGWRkY  PFNk iAYP BG^ BHHtsx{vuxgokkGWRk_XXP] C^Mk iAYP BG^ BW[Z@]ZAQ>LUSB\\__NLP^	tsx{vuxgokkGWRkS\CU__XX EZkiAYP BG^ BC[Q BXUWQ_NBBAMFZRCA_RE^PELQPC[Q BXUW>]RLUSB\\__NLP^		RUXGQO>]RtRX[W_LUSB\\__NLP^x{wkqlHx{wkzvO>tRWX[GQLUSB\\__NLP^>FQ@AFZRUXGQ>I>>]R]GGQ@sx{vuxgoYLW ^L@NiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoRS^]Q]]ZB@[Uisx{vuxgoC[Q BXUi	UFFUM>>>sx{vuxgoC[Q BXUio_RE^PELQPi	LUSB\\__NLP^>sx{vuxgoXSDQk^Y[_N[ io_RE^PELQPi	>>FQ@AFZ@FAQ>I>I>I>sx{vuxgoRS^]Q]]ZB@[Uio_RE^PELQPi	>sx{vuxgoRS^]Q]]ZB@[Uio_RE^PELQPi	>FQ@AFZ@FAQ>I>RAZW@][ZL^U[US^\kM^_RE^PELQP>O>SX[VUXCDPV>>]RQYD@Msx{vuxgoNWCUNEMio_RE^PELQPiFQ@AFZ>sx{vuxgoYLW ^L@Nio_RE^PELQPi>]Rsx{vuxgoRS^]Q]]ZB@[Uio_RE^PELQPi
FQ@AFZ>AZGQ@sx{vuxgoNWCUNEMio_RE^PELQPi>AZGQ@sx{vuxgoNWCUNEMio_RE^PELQPi>AZGQ@sx{vuxgoNWCUNEMio_RE^PELQPi>]R]GGQ@sx{vuxgoYLW ^L@Nio_RE^PELQPiO>tRX[W_sx{vuxgoXSDQk^Y[_N[  io_RE^PELQPix{wkaz>tRWX[GQsx{vuxgoXSDQk^Y[_N[ io_RE^PELQPi>>>AZGQ@sx{vuxgoC[Q BXUio_RE^PELQPi>I>]Rsx{vuxgokkGWRk@L\SQY@ZAkiCDPVsx{vuxgokkGWRkUU\RUWEQkiCDPVYLW ^L@NO>tCDPV
EAQFMYLW ^L@NWQ_NBBAMFZRCA_RE^PELQPYLW ^L@N>I>>I>RAZW@][ZBZVkBZC[SWGQ>>>>O>]RPQR]ZQPC[Q BXUp}guxx{ckr}xqky{pgFQ@AFZRUXGQ>FQ@AFZ@FAQ>>>>I>RAZW@][Z[_LD^ LEBAYPDLP>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U HHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZRUXGQ>_[N ZA[D[Z\^_	UFFUM>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  _[N ZA[D[Z\^_oi	sx{vuxgokkGWRkLBBNYWPX^Dki>]RPQR]ZQPYLW ^L@N_[N ZA[D[Z\^_oi	cdkw{z`qz`kp}f>]RPQR]ZQPU_GSMD@V_[N ZA[D[Z\^_oi	sx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|XSDQk^Y[_N[ >R[FQUW\_[N ZA[D[Z\^_UGU@AQDW\BS[SO>]RU@AQDW\BS[S			HHtsx{vuxgokkGWRkY  PFNk iU@AQDW\BS[SHHtsx{vuxgokkGWRk_XXP] C^Mk iU@AQDW\BS[SW[Z@]ZAQ>LADCV	tsx{vuxgokkGWRkS\CU__XX EZkiU@AQDW\BS[SXSDQk^Y[_N[ WQ_NBBAMFZRCANWCUNEM RS^]Q]]ZB@[U W>>>]RLADCV			RUXGQW[Z@]ZAQ>>>>]RtRX[W_LADCVx{wkqlHx{wkzvO>tRWX[GQLADCV>FQ@AFZRUXGQ>I>sx{vuxgoRS^]Q]]ZB@[U i	LADCV>FQ@AFZ@FAQ>I>FQ@AFZRUXGQ>>>I>RAZW@][ZCA [GQ_ QYD@@C>>O>]R]GGQ@sx{vuxgoC[Q BXU iO>>>>tRX[W_sx{vuxgoNWCUNEM ix{wkaz>tRWX[GQsx{vuxgoYLW ^L@N i>AZGQ@sx{vuxgoU_GSMD@V i>I>>>I>RAZW@][ZCWLVVG\WZFFAPYAM @_MYB[A>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N  HHsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM FQ@AFZ>]R[_LD^ LEBAYPDLPFQ@AFZ>@FMO>WYU^@@UEVX]	SQ@k[D@][ZXSDQk^Y[_N[  UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iWYU^@@UEVX]WYU^@@UEVX]	UFFUM>>>>W\B\kP\XkU@QM	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRk_SM[G_FkLFk iWYU^@@UEVX]>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iYAM @_MYB[AW\B\kP\XkU@QM@FAQW\B\kP\XkU@QMoi	YAM @_MYB[A>]RW\B\kP\XkU@QM		WYU^@@UEVX]ADPU@Qk[D@][ZU_GSMD@V W\B\kP\XkU@QM>AZGQ@W\B\kP\XkU@QM>>>IR]ZUXXMO>CA [GQ_ QYD@@C>>>I>I>RAZW@][ZL@VRkGRYk\XSRWYAM @_MYB[A>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N  HHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U FQ@AFZ>>>]R[_LD^ LEBAYPDLPFQ@AFZ>@FMO>WYU^@@UEVX]	SQ@k[D@][ZXSDQk^Y[_N[  UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iWYU^@@UEVX]sx{vuxgokkGWRkUFBG[ZLZN Gk iYAM @_MYB[AWYU^@@UEVX]@FAQO>ADPU@Qk[D@][ZXSDQk^Y[_N[  sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRkk\SZ\YY kiWYU^@@UEVX]UFFUMYAM @_MYB[A>I>IR]ZUXXMO>CA [GQ_ QYD@@C>I>>>>I>RAZW@][Z[]\CNNBEZB[Q\APGUMSPCLPkY[GD[EZLN>O>@FMO>]R]Z@QFRUWQkQL]G@GYLW ^L@N[GD[EZLN]ZG@UZWQ[R`\F[CUVXQO>D]UVNBSQUX	sx{vuxgokkGWRkQDZV_kiUMSPCLPkYNWCUNEM[GD[EZLN
SQ@yQGGUSQLVQL >IQXGQ]R[GD[EZLN]ZG@UZWQ[RqLWQD@][ZO>D]UVNBSQUX	sx{vuxgokkGWRkQDZV_kiUMSPCLPkYU_GSMD@V[GD[EZLN
SQ@yQGGUSQ  >IQXGQ]Rsx{vuxgokkGWRkCGC  VMVVk i[GD[EZLNsx{vuxgokkGWRkD@WYYENNCMMkki[GD[EZLN
O>D]UVNBSQUX	sx{vuxgokkGWRkQDZV_kiUMSPCLPkYYLW ^L@N[GD[EZLN >IQXGQO>FQ@AFZ>I>>>]R]GGQ@sx{vuxgoXSDQk^Y[_N[ isx{vuxgoXSDQk^Y[_N[ i	UFFUM>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iD]UVNBSQUXsx{vuxgoC[Q BXU i@FAQO>sx{vuxgoNWCUNEM ioi	D]UVNBSQUX>I>>>]Rsx{vuxgokkGWRkEMVLY\Akisx{vuxgoRS^]Q]]ZB@[Ui
LPLO>sx{vuxgoU_GSMD@Vi	sx{vuxgokkGWRkXY\ECNkLB^@kisx{vuxgoYLW ^L@Ni >I>IWU@W\`\F[CUVXQQWVWGU]_V_PBO>IWU@W\qLWQD@][ZQWVWGU]_V_PBO>I>I>>>>RAZW@][ZVMR^VBCUFWXDYMN[U\CB@ RCGXU_ NQDLS[G[SLUkFX_AZZZFQ	ZFR GB^_Z	>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iU_ NQDLS[G[SO>FQ@AFZUPPkUW@][ZYMN[U\CB@ RCGXRAZW@][ZASZV\NZ@LAGQU_ NQDLS[G[SO>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_ NQDLS[G[SFQ@AFZU_ NQDLS[G[SASZV\NZ@L>FQ@AFZZAXX>ILUkFX_AZZZFQZFR GB^_Z>I>FQ@AFZUPPkUW@][ZYMN[U\CB@ RCGXU_ NQDLS[G[SLUkFX_AZZZFQZFR GB^_Z>I>RAZW@][Z_GPVPERFUC@RL[RYMN[U\CB@ RCGXU_ NQDLS[G[SLUkFX_AZZZFQ	ZFR GB^_Z	>>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iU_ NQDLS[G[SO>FQ@AFZUPPkR]X@QFYMN[U\CB@ RCGXRAZW@][ZASZV\NZ@LAGQU_ NQDLS[G[SO>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_ NQDLS[G[SFQ@AFZU_ NQDLS[G[SASZV\NZ@L>FQ@AFZ]GGQ@ASZV\NZ@LoiASZV\NZ@LoiZAXX>ILUkFX_AZZZFQZFR GB^_Z>I>FQ@AFZUPPkR]X@QFYMN[U\CB@ RCGXU_ NQDLS[G[SLUkFX_AZZZFQZFR GB^_Z>>>I>RAZW@][ZGM_EAV^VFW>>>>O>PLDRFkX ]D]@Y]	PQR]ZQPXSDQk^Y[_N[ cdkw{z`qz`kp}fU_GSMD@VSL@D ]FAVZuvgdu`|YLW ^L@Nsx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZYLW ^L@N>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]QWY_NPDE^_ZPLDRFkX ]D]@Y]O>GEWVN@XUE@ P\\ZPLDRFkX ]D]@Y] @FAQ>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]O>_ W^\V CPNY_PLDRFkX ]D]@Y]RS^]Q]]ZB@[UD\Dg]XQZWQ]GS[XPQZhZNWCUNEM>I>>>>I>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]tsx{vuxgokkGWRk_XXP] C^Mk iPLDRFkX ]D]@Y]O>FQ@AFZPLDRFkX ]D]@Y]>>>I>_k@ULGUF	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>]Rtsx{vuxgokkGWRkY  PFNk i_k@ULGUFQWY_NPDE^_Z_k@ULGUFGEWVN@XUE@ P\\Z_k@ULGUF  @FAQ>]Rtsx{vuxgokkGWRkY  PFNk i_k@ULGUFtsx{vuxgokkGWRk_XXP] C^Mk i_k@ULGUFFQ@AFZ_k@ULGUF>NFV^ _VUESL	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZ>]Rtsx{vuxgokkGWRk_XXP] C^Mk iNFV^ _VUESLNFV^ _VUESL		VZ[[SF]P]DGWUAZFQ@AFZNFV^ _VUESL>]RPQR]ZQPU_GSMD@V tsx{vuxgokkGWRk_XXP] C^Mk icdkw{z`qz`kp}fQWY_NPDE^_Zcdkw{z`qz`kp}fFQ@AFZcdkw{z`qz`kp}f>FQ@AFZPLDRFkX ]D]@Y]>I>RAZW@][ZAEZGREWF[>O>]RPQR]ZQPNWCUNEM tsx{vuxgokkGWRk_XXP] C^Mk icdkw{z`qz`kp}fQWY_NPDE^_Zcdkw{z`qz`kp}fFQ@AFZcdkw{z`qz`kp}f>>Z^FXPW@R@SEW	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZ>]RQWY_NPDE^_ZZ^FXPW@R@SEWFQ@AFZZ^FXPW@R@SEW>>>FQ@AFZcdkw{z`qz`kp}f>I>>>>RAZW@][ZV@  NBWM[ML[CDCPZkSGSNUN>O>]RQYD@Msx{vuxgoRS^]Q]]ZB@[UiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoYLW ^L@NiFQ@AFZRUXGQ>]R]GGQ@sx{vuxgoYLW ^L@NioDCPZkSGSNUNiFQ@AFZ@FAQ>>XkSFk\[LMkP	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vtsx{vuxgokkGWRkC]YQRGZkiDCPZkSGSNUNRUXGQ>FQ@AFZXkSFk\[LMkP		RUXGQ]GGQ@sx{vuxgoU_GSMD@VioXkSFk\[LMkPi>I>>>>RAZW@][ZDM]]_DB]WPQAMWYEEDCPZkSGSNUN>>>O>>>>]RQYD@Msx{vuxgoC[Q BXUiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoC[Q BXUiFQ@AFZ>AZGQ@sx{vuxgoC[Q BXUioDCPZkSGSNUNi>XkSFk\[LMkP	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tsx{vuxgokkGWRkC]YQRGZkiDCPZkSGSNUNRUXGQ>]RXkSFk\[LMkP		RUXGQAZGQ@sx{vuxgoXSDQk^Y[_N[ ioXkSFk\[LMkPi>I>>RAZW@][ZWVZ\ANZRNDMXWk^DCPZkSGSNUN>O>]R]GGQ@sx{vuxgoRS^]Q]]ZB@[UiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoXSDQk^Y[_N[ iO>sx{vuxgoRS^]Q]]ZB@[Ui	UFFUM>I>]]RB__ZRRX	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vtsx{vuxgokkGWRkC]YQRGZkiDCPZkSGSNUNRUXGQ>sx{vuxgoNWCUNEMio]]RB__ZRRX		RUXGQ]]RB__ZRRXDCPZkSGSNUNi	DCPZkSGSNUN>G@U@]W^BZYSSN EZRN]X	RUXGQ>]R^BZYSSN EZRN]XO>>>^BZYSSN EZRN]X	@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ sx{vuxgokkGWRkA[^M[ DkiU_GSMD@V>>I>>>>I>RAZW@][ZF ZBAFFUU[EEGZZMU>O>]RQYD@Msx{vuxgoNWCUNEM iHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoXSDQk^Y[_N[  iO>>>FQ@AFZ>>I>R[FQUW\sx{vuxgoXSDQk^Y[_N[ iUG@ZENY][]YFU	
^[D@@BEFO>]Rsx{vuxgokkGWRkCGC  VMVVk i^[D@@BEF^[D@@BEF	@ZENY][]YFU>]R@ZENY][]YFU			R^N]SFX^UDZ^SGFZHH^[D@@BEF			R^N]SFX^UDZ^SGFZW[Z@]ZAQ>@FMO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki^[D@@BEFSQNV[\]PPZU^[D@@BEFG[V]FSPk\ Z]^AB_P^[D@@BEFO>CBZR\RDFU\DVGMSkG^[D@@BEF>Q^YGW\LCNk[ZN^[D@@BEF>I>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>I>RAZW@][ZkYMC_BSMBARZ\_kZ>O>>@FMO>[GD[EZLN	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UtQFF[FkSQ@kXUG@ZAXX>]Rsx{vuxgokkGWRkWBSB\_k i[GD[EZLNHHQYD@M[GD[EZLNoU_GSMD@ViHHQYD@M[GD[EZLNoU_GSMD@ViFQ@AFZ>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk i[GD[EZLNoYLW ^L@NiUFFUMqkqff{fqkdufgqqkw{fqkqff{fqkw{yd}xqkqff{fqkagqfkqff{f@FAQFQ@AFZ>WCLB@]UG	]GGQ@[GD[EZLNoU_GSMD@ViG@F]ZS[GD[EZLNoRS^]Q]]ZB@[Ui>]RG@F]D[GWCLB@]UGU_GSMD@V		RUXGQHHG@F]D[GWCLB@]UGU_GSMD@V		RUXGQFQ@AFZ>SkYVANG	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Ntsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZR^N]SFX^UDZ^SGFZ>kQR	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tsx{vuxgokkGWRkC]YQRGZki[GD[EZLNoNWCUNEMi[GD[EZLNoYLW ^L@Ni>]Rsx{vuxgokkGWRkCGC  VMVVk iSkYVANGHHsx{vuxgokkGWRkCGC  VMVVk ikQRHHkQR		SkYVANGFQ@AFZ>]R]GGQ@sx{vuxgoU_GSMD@ViO>\SFD@CP\@	tsx{vuxgokkGWRkBYEVDGkUNk iR^N]SFX^UDZ^SGFZRUXGQZAXXLW LVR>]Rsx{vuxgokkGWRkCGC  VMVVk i\SFD@CP\@sx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@N\SFD@CP\@kPYkPYoi		G@F]ZSsx{vuxgoRS^]Q]]ZB@[UiFQ@AFZ>AZGQ@\SFD@CP\@kPY>>]R]GGQ@sx{vuxgoYLW ^L@NiO>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtWXQUFG@U@WUW\Q@FAQR^N]SFX^UDZ^SGFZ>VW^D\NEG^UL	G@F]ZStsx{vuxgokkGWRkDNNU_UYWXVVkiR^N]SFX^UDZ^SGFZG@F]ZStsx{vuxgokkGWRkUMX_NCYCkiR^N]SFX^UDZ^SGFZ>]RVW^D\NEG^UL		G@F]ZSsx{vuxgoXSDQk^Y[_N[ iFQ@AFZ>AZGQ@VW^D\NEG^UL>>>I>>I>>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>k^CBQWRFQQ	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>EXSUC@F[V\SYV	sx{vuxgokkGWRkCGC  VMVVk ik^CBQWRFQQsx{vuxgokkGWRkk[AFM@ZWUECkik^CBQWRFQQ>AZGQ@k^CBQWRFQQ>]REXSUC@F[V\SYV		O>_ W^\V CPNY_sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZNWCUNEMkMZ[W\L[YU[EXSUC@F[V\SYVE>_ W^\V CPNY_sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZU_GSMD@V EXSUC@F[V\SYVG@F]ZSsx{vuxgokkGWRkNWYM^SkLZ[BNkiE>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM O>>tADPU@Qk[D@][ZU_GSMD@VEXSUC@F[V\SYVHsx{vuxgokkGWRkNWYM^SkLZ[BNkiU_GSMD@V>I>I>>>BRMUD]WD	VZ[[SF]P]DGWUAZ>>]REXSUC@F[V\SYV		BRMUD]WD		sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZtsx{vuxgokkGWRkY  PFNk iBRMUD]WDtsx{vuxgokkGWRk_XXP] C^Mk iBRMUD]WDO>_ W^\V CPNY_BRMUD]WDU_GSMD@VkMZ[W\L[YU[EXSUC@F[V\SYVE>>>I>>L@VRkGRYk\XSRW[LYRkLY]QU>Z^kkDCPSE^ CUkC[Q BXU>DXVGUR^A	R^N]SFX^UDZ^SGFZC[Q BXU>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  tsx{vuxgokkGWRkX QBXDFYNZBk iR^N]SFX^UDZ^SGFZDXVGUR^A>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>t[DWUW\Qk]ZBUX]PU@QR^N]SFX^UDZ^SGFZ@FAQ>t[DWUW\Qk]ZBUX]PU@QDXVGUR^A@FAQ>I>R[FQUW\UFFUMsx{vuxgokkGWRkWLGRkXNMY[kiDXVGUR^AVZ[[SF]P]DGWUAZUGBAk@QY_E_F]BO>VXVBVCFBYQ	[FZWA_XLGNXRBAk@QY_E_F]B >]Rsx{vuxgokkGWRkWBSB\_k iVXVBVCFBYQW[Z@]ZAQ>R[FQUW\VXVBVCFBYQUGRPECFD@U@O>>>>]Rsx{vuxgokkGWRkQDZV_kiRPECFD@U@LL		YLW ^L@NW[Z@]ZAQ>X EC[RD	BAk@QY_E_F]BRPECFD@U@>QRPNFB[\A	tsx{vuxgokkGWRkUMX_NCYCkiX EC[RD>]RQRPNFB[\AQRPNFB[\Asx{vuxgokkGWRkNWYM^SkLZ[BNki O>SUB\XXALLBWR W\F XX EC[RD>>>>UC[WM Z X EC[RD>I>>I>>>I>AZGQ@BAk@QY_E_F]BVXVBVCFBYQRPECFD@U@X EC[RDQRPNFB[\A>IWU@W\`\F[CUVXQQWVWGU]_V_PBO>IWU@W\qLWQD@][ZQWVWGU]_V_PBO>I>I>RAZW@][ZVFk\E[[BAL]CZDCPZkSGSNUNB[QYSFB[FMW\@>O>@FMO>]Rsx{vuxgokkGWRkCGC  VMVVk iDCPZkSGSNUNHHDCPZkSGSNUN			HHsx{vuxgokkGWRkCGC  VMVVk iB[QYSFB[FMW\@HHB[QYSFB[FMW\@			FQ@AFZ>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]HHtsx{vuxgokkGWRk_XXP] C^Mk iPLDRFkX ]D]@Y]FQ@AFZ>Z[Y_WX[CBS	PLDRFkX ]D]@Y]C[Q BXUsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUNNWCUNEM>VM]ZQ]_@BMXD	tsx{vuxgokkGWRkBYEVDGkUNk iZ[Y_WX[CBS>]Rsx{vuxgokkGWRkCGC  VMVVk iVM]ZQ]_@BMXDsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ VM]ZQ]_@BMXDWCLB@]UGBQFG][ZkW[YDUFQWCLB@]UGoiB[QYSFB[FMW\@RS^]Q]]ZB@[UFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V tsx{vuxgokkGWRk_GUYNZVVVk iZ[Y_WX[CBSB[QYSFB[FMW\@>IWU@W\`\F[CUVXQ[GD[EZLNO>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZYLkS@ ^CN GkM>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V  O>FQ@AFZ>I>]RtSQ@k[D@][ZRS^]Q]]ZB@[UO>VMR^VBCUFWXDYLW ^L@NNWCUNEM>I>>>>]RPZEURB[UWFUPU_GSMD@VFQ@AFZ>>SASXkDk  _	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiuvgdu`|G@F]ZS^@U[FB_S@YGNYEL>BVPD\EUFkD	G@F]ZStSQ@k[D@][ZSASXkDk  _>FQ^V_ V SVQ	XSDQk^Y[_N[ >>>>NNPGUEWYV	>>DVNS[DL]WL	G@FFQB\ASSNCBDS[ZG^>@E_^\Y A	XCDS]V]N]\U[DX C>PM__	@E_^\Y AHDVNS[DL]WL>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiBVPD\EUFkDH		RUXGQO>[@AUPRDF@C^GU	sx{vuxgokkGWRkPF]F GWR@ZkiHBVPD\EUFkD>FQ^V_ V SVQ	[@AUPRDF@C^GUoi>NNPGUEWYV	[@AUPRDF@C^GUoi>IQXGQO>>NNPGUEWYV	BVPD\EUFkD>I>>]RNNPGUEWYVO>>tADPU@Qk[D@][ZSASXkDk  _PM__XSDQk^Y[_N[ >FQ@AFZ>>>I>>]RNNPGUEWYV			DVNS[DL]WLO>]RBVPD\EUFkD		PM__BQFG][ZkW[YDUFQ@E_^\Y AFQ^V_ V SVQXSDQk^Y[_N[ O>tADPU@Qk[D@][ZSASXkDk  _PM__RS^]Q]]ZB@[U>>>I>FQ@AFZ>I>>[_QZQE]BFQE	G@FFQBNNPGUEWYV>]R[_QZQE]BFQE			HHsx{vuxgokkGWRkQANE SG_kXV\ki[_QZQE]BFQE		[_QZQE]BFQEO>>tADPU@Qk[D@][ZSASXkDk  _PM__XSDQk^Y[_N[ >FQ@AFZ>I>>CANES @kLZ	VZ[[SF]P]DGWUAZ[_QZQE]BFQE>>>V ]YY PPDXL ]	>]RPQR]ZQPXSDQk^Y[_N[ O>>V ]YY PPDXL ]	cdkdxas}zkp}fsx{vuxgokkGWRk[\CPGL _]GZki[_QZQE]BFQEdu`|}zr{kr}xqzuyq[_QZQE]BFQE>>>>I>>_BWPMWEL]@R 	tsx{vuxgokkGWRkDNNU_UYWXVVkiCANES @kLZ>D@@WZWQVLX_U	_BWPMWEL]@R 		RUXGQ_BWPMWEL]@R 
	>CXN@RXUA]S	V ]YY PPDXL ]tsx{vuxgokkGWRkDNNU_UYWXVVkiV ]YY PPDXL ]RUXGQ>F A\\GA@ZU	CXN@RXUA]S		RUXGQCXN@RXUA]S
	  >>]RD@@WZWQVLX_UF A\\GA@ZUO>tADPU@Qk[D@][ZSASXkDk  _PM__RS^]Q]]ZB@[U>FQ@AFZ>I>>>>GGYX_VSk]	D@@WZWQVLX_UCANES @kLZV ]YY PPDXL ]>LADCV	tsx{vuxgokkGWRkBYEVDGkUNk iGGYX_VSk]RUXGQZAXX  >]Rsx{vuxgokkGWRkCGC  VMVVk iLADCVsx{vuxgokkGWRkUQ Y]ZXWDkiU_GSMD@VLADCVkRYO>FQ^V_ V SVQ	kRYoi>IQXGQ]RkACM_XP_VCUZ YkLGGYX_VSk] O>>>>FQ^V_ V SVQ	C[Q BXU>>>>I>AZGQ@LADCVkRY>YEALAF_URMUC^Z	D@@WZWQVLX_U>]RYEALAF_URMUC^ZF A\\GA@ZUO>XL\@[@VUX_NAEW	sx{vuxgokkGWRk[\CPGL _]GZki[_QZQE]BFQEdu`|}zr{kr}xqzuyq[_QZQE]BFQE>>^@RNW_]kVSNAU	UFFUMtSQ@k[D@][ZYLW ^L@N UFFUM>YEALAF_URMUC^Z	sx{vuxgokkGWRkUFBG[ZLZN Gk iXL\@[@VUX_NAEW^@RNW_]kVSNAU@FAQ>]RYEALAF_URMUC^Zsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U ]GkYAX@]G]@Qsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>N@VBL^^[@@	UFFUMtSQ@kG]@Qk[D@][ZXSDQk^Y[_N[ UFFUM>YEALAF_URMUC^Z	]GGQ@N@VBL^^[@@oXL\@[@VUX_NAEWi>AZGQ@N@VBL^^[@@>I>AZGQ@XL\@[@VUX_NAEW^@RNW_]kVSNAU>I>UYBWX\BD GW@	BQFG][ZkW[YDUFQ@E_^\Y AFQ^V_ V SVQ>]RUYBWX\BD GW@	O>B[[BBZF[^YkCEU	kACM_XP_VCUZ YkLGGYX_VSk]   >EVZZCPU \_L	]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiGGYX_VSk]>ZPFXBVC^YMQZ	B[[BBZF[^YkCEUHHEVZZCPU \_L
L LWWVU>]RZPFXBVC^YMQZEVZZCPU \_L
  O>VQBZWGF	tsx{vuxgokkGWRkBYEVDGkUNk iGGYX_VSk]RUXGQZAXX >]Rsx{vuxgokkGWRkCGC  VMVVk iVQBZWGFHHsx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@NVQBZWGFZPFXBVC^YMQZ	@FAQ>>I>]RZPFXBVC^YMQZ@R[P][SEWQZV\PGGYX_VSk]ZPFXBVC^YMQZ	@FAQ>]RZPFXBVC^YMQZO>>^@ SQP\kPPV	SSLFDW@VYW[X]BXX>]RQYD@M^@ SQP\kPPVoU_GSMD@ViO>>>F\EMB^NLM	tsx{vuxgokkGWRkC]YQRGZki^@ SQP\kPPVoU_GSMD@Vi>@YE\CSUXYX_ _Z	tsx{vuxgokkGWRkC]YQRGZkiGGYX_VSk]>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iF\EMB^NLMsx{vuxgokkGWRkCGC  VMVVk i@YE\CSUXYX_ _ZF\EMB^NLM			@YE\CSUXYX_ _ZO>BWB\Rk@k	^ABU@ML^PF^MW^@ SQP\kPPV>>>]RBWB\Rk@k			XSDQk^Y[_N[ HHBWB\Rk@k			RS^]Q]]ZB@[UZPFXBVC^YMQZ	@FAQ>I>AZGQ@F\EMB^NLM@YE\CSUXYX_ _ZBWB\Rk@k>>>>I>]RZPFXBVC^YMQZZk RVYS[@^S WQSAGGYX_VSk]ZPFXBVC^YMQZ	@FAQ>AZGQ@^@ SQP\kPPV>I>]RZPFXBVC^YMQZO>>>>]RB[[BBZF[^YkCEUWVZ\ANZRNDMXWk^GGYX_VSk]>tADPU@Qk[D@][ZSASXkDk  _PM__U_GSMD@V>FQ@AFZ>I>]RYEALAF_URMUC^ZO>tADPU@Qk[D@][ZSASXkDk  _PM__YLW ^L@N>FQ@AFZ>I>]RGW\A]MX]PXDSGGYX_VSk]R^N]SFX^UDZ^SGFZO>tADPU@Qk[D@][ZSASXkDk  _PM__XSDQk^Y[_N[ >FQ@AFZ>I>]RUYBWX\BD GW@HHUYBWX\BD GW@			sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkisx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkisx{vuxgokkGWRkQANE SG_kXV\ki[_QZQE]BFQENWCUNEMO>VFk\E[[BAL]CZR^N]SFX^UDZ^SGFZFQ^V_ V SVQ>UGPBCFYDGYFM [R^N]SFX^UDZ^SGFZ>FQ@AFZ@FAQ>I>>I>]RQYD@Msx{vuxgoXSDQk^Y[_N[ iO>sx{vuxgoRS^]Q]]ZB@[Ui	@FAQ>>]RkACM_XP_VCUZ YkLGGYX_VSk]LLUWVZ\ANZRNDMXWk^GGYX_VSk]>L]XP_M_	sx{vuxgokkGWRkNWYM^SkLZ[BNki>M^EGF^k]GM C[ZM R^N]SFX^UDZ^SGFZL]XP_M_L]XP_M_ ^@U[FB_S@YGNYEL>AZGQ@L]XP_M_>VFk\E[[BAL]CZCANES @kLZ@E_^\Y A>]RV ]YY PPDXL ]VFk\E[[BAL]CZV ]YY PPDXL ]@E_^\Y A>VMR^VBCUFWXDU_GSMD@VRS^]Q]]ZB@[U>tADPU@Qk[D@][ZSASXkDk  _PM__RS^]Q]]ZB@[U >Z^kkDCPSE^ CUkYLW ^L@N>]RV ]YY PPDXL ]		O>L@VRkGRYk\XSRWsx{vuxgokkGWRk[\CPGL _]GZki[_QZQE]BFQEdu`|}zr{kr}xqzuyq[_QZQE]BFQE>I>>I>FQ@AFZ>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>IR]ZUXXMO>L^U[US^\kM^NWCUNEM>>I>I>>>RAZW@][Z[FZWA_XLGNXRPLDRFkX ]D]@Y]^GWFQS\L	>>>O>^GWFQS\L	]Z@^GWFQS\L>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Usx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>DGW]PX\GXA	tsx{vuxgokkGWRkkNUQ EZ[V@NFkiPLDRFkX ]D]@Y]>]RDGW]PX\GXAO>\MkR ADAkL[S	UFFUM>C\]XQ[GD[EZLN	tsx{vuxgokkGWRkMPYG\URZM[DkiDGW]PX\GXA		RUXGQO>]R[GD[EZLN		[GD[EZLN		RS^]Q]]ZB@[U  \MkR ADAkL[Soi	[GD[EZLN>]R^GWFQS\L
sx{vuxgokkGWRkEMVLY\Aki\MkR ADAkL[S
	^GWFQS\LVFQU_>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Utsx{vuxgokkGWRkEYNYY[WSXFkiDGW]PX\GXA>FQ@AFZ\MkR ADAkL[S>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V O>>>>]MC[kQAAGC	tsx{vuxgokkGWRkZ][LAE N FkiPLDRFkX ]D]@Y]>]Rsx{vuxgokkGWRkWBSB\_k i]MC[kQAAGCO>]MC[kQAAGC	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRkk\SZ\YY ki]MC[kQAAGCUFFUMRS^]Q]]ZB@[U  >>>]R^GWFQS\L
sx{vuxgokkGWRkEMVLY\Aki]MC[kQAAGC
^GWFQS\L]MC[kQAAGC	sx{vuxgokkGWRkXY\ECNkLB^@ki]MC[kQAAGC^GWFQS\L>FQ@AFZ]MC[kQAAGC>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>[kC] Ak	tsx{vuxgokkGWRkV^E_YEEGLMVkiPLDRFkX ]D]@Y]YLW ^L@N>]Rsx{vuxgokkGWRkWBSB\_k i[kC] AkO>]R^GWFQS\L
sx{vuxgokkGWRkEMVLY\Aki[kC] Ak
^GWFQS\L[kC] Ak	sx{vuxgokkGWRkXY\ECNkLB^@ki[kC] Ak^GWFQS\L>FQ@AFZsx{vuxgokkGWRkEZVQ\Y]LBkiXSDQk^Y[_N[ [kC] Ak>I>I>>>FQ@AFZZAXX>I>RAZW@][ZMSVkZG[@_ P@LXY@Z[D[X>O>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U FQ@AFZZAXX>>>YGR@MYGWCC	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ G@F]ZStsx{vuxgokkGWRkQZNVM]LkiU_GSMD@V>]RYGR@MYGWCC		G@F]D[GYGR@MYGWCCRS^]Q]]ZB@[U 		RUXGQFQ@AFZZAXX>]R\@GAGYQZ	YZM]DQZ RCCYZAsx{vuxgokkGWRkLBBNYWPX^DkiRS^]Q]]ZB@[U>>>>]R]R\@GAGYQZ			RUXGQFQ@AFZZAXX>]Rtsx{vuxgokkGWRk_GUYNZVVVk i]R\@GAGYQZY@Z[D[X		sx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[XO>UC[WM Z ]R\@GAGYQZ>>>>FQ@AFZZAXX>I>EM]_VBWC]RV	tsx{vuxgokkGWRkUPCY^GQBA@k iC[Q BXUQGWUDQG\QXXUFS]R\@GAGYQZYLW ^L@N>UC[WM Z ]R\@GAGYQZ>]Rsx{vuxgokkGWRkCGC  VMVVk iEM]_VBWC]RVHHEM]_VBWC]RV			FQ@AFZZAXX>]RG@F]D[GEM]_VBWC]RVXSDQk^Y[_N[ 		RUXGQFQ@AFZ@FAQ>]RG@F]D[GEM]_VBWC]RVXSDQk^Y[_N[ 		RUXGQHHG@F]D[GEM]_VBWC]RVC[Q BXU 		RUXGQFQ@AFZRUXGQ>FQ@AFZZAXX>I>RAZW@][ZM[YQk NNVYMFB\Y@Z[D[X>O>G@U@]WBSDGBS_YADM	UFFUM>]Rsx{vuxgokkGWRkCGC  VMVVk iY@Z[D[XHHsx{vuxgokkGWRkUAU[DUV]kWkiY@Z[D[XYLW ^L@N 			RUXGQFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[X
LPLPRQQY@Z[D[X	^UNF\NZMLZLZkN[XAY@Z[D[X>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[X
 FQ@AFZRUXGQ>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V FQ@AFZ@FAQ>WDWFFGG	sx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[Xsx{vuxgokkGWRkk[AFM@ZWUECkiY@Z[D[X>]Rsx{vuxgokkGWRkVQRVVAQZLk iWDWFFGGBSDGBS_YADMFQ@AFZBSDGBS_YADMoWDWFFGGi>Q]PWV\A_Y	P@NWYNYBSNY@Z[D[X>]Rsx{vuxgokkGWRkEMVLY\AkiBSDGBS_YADM
LVLPBSDGBS_YADM	UFFUM>BSDGBS_YADMoWDWFFGGi	Q]PWV\A_Y>FQ@AFZQ]PWV\A_Y>I>RAZW@][ZP@NWYNYBSNY@Z[D[X>O>]RPQR]ZQPYLW ^L@N  O>>>EkMXALMZQZM@	MRM QRSUkX N Msx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[X>]REkMXALMZQZM@O>_WLRG UFA]	t@[_QZkSQ@kUXXY@Z[D[X>]Rsx{vuxgokkGWRkWBSB\_k i_WLRG UFA]FQ@AFZ@FAQ>>_AQLYZX@	>[FN^YXPZ	>WXS_LGR	>R[FQUW\_WLRG UFA]UG[C[ALERkBO>>>]Rsx{vuxgokkGWRkWBSB\_k i[C[ALERkBO>]R[C[ALERkBoi			`kwafxmk{dqzHH[C[ALERkBoi			`kp{xxufk{dqzkwafxmkvfuwqg_AQLYZX@>W[Z@]ZAQ>I>>>>]R[C[ALERkB			O_AQLYZX@>QXGQ]R[C[ALERkB			IO>_AQLYZX@>>]R_AQLYZX@FQ@AFZRUXGQ>IQXGQ]R[C[ALERkB			[FN^YXPZ>>>>QXGQ]R[C[ALERkB			O>[FN^YXPZ>]R[FN^YXPZFQ@AFZRUXGQ>IQXGQ]R[C[ALERkB			oWXS_LGR>QXGQ]R[C[ALERkB			iO>WXS_LGR>]RWXS_LGRFQ@AFZRUXGQ>I>I>]R_AQLYZX@		HH[FN^YXPZ		HHWXS_LGR		FQ@AFZRUXGQ>I>AM[FGYL\EPA	MSVkZG[@_ P@LXY@Z[D[X>]Rsx{vuxgokkGWRk\ VZCZD@AXk iAM[FGYL\EPAFQ@AFZAM[FGYL\EPA>FQ@AFZEkMXALMZQZM@>I>]RMRM QRSUkX N Msx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[XO>AM[FGYL\EPA	MSVkZG[@_ P@LXY@Z[D[X>FQ@AFZsx{vuxgokkGWRk\ VZCZD@AXk iAM[FGYL\EPAAM[FGYL\EPARUXGQ>I>@FMO>t@[_QZkSQ@kUXXY@Z[D[X`{qzkdufgq>FQ@AFZ@FAQ>IWU@W\`\F[CUVXQ[GD[EZLNO>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>FQ@AFZRUXGQ>I>I>>>>RAZW@][ZLk_@Y ZRB]][LD VZY]>O>FQ@AFZUFFUMRS^]Q]]ZB@[U XSDQk^Y[_N[  XSDQk^Y[_N[  >I>RAZW@][ZMDU[^WVEZSEkNXZV]\>O>FQ@AFZUFFUMU_GSMD@V RS^]Q]]ZB@[UXSDQk^Y[_N[ NWCUNEMU_GSMD@VRS^]Q]]ZB@[U YLW ^L@NRS^]Q]]ZB@[UU_GSMD@VU_GSMD@VYLW ^L@NU_GSMD@VXSDQk^Y[_N[ C[Q BXUNWCUNEMYLW ^L@N YLW ^L@NC[Q BXUYLW ^L@NXSDQk^Y[_N[ >>>I>RAZW@][ZQQ\E@[^PEBRYMZ^PV>O>>FQ@AFZUFFUMU_GSMD@VYLW ^L@NXSDQk^Y[_N[ RS^]Q]]ZB@[U>I>>RAZW@][ZF[GDUDUYA_[_^kQARR_QCDM^ @W>O>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZSNQZW[PQRR_QCDM^ @W>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>FQ@AFZhLRhLVhLhLhLhLhLhLhLhLSNPQRXU@QRR_QCDM^ @Wsx{vuxgokkGWRkRYPXC^kMkEFkibsx{vuxgokkGWRkBBVZWNMLUGXG[kiRR_QCDM^ @Wsx{vuxgokkGWRkRYPXC^kMkEFkibsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @WLWVVPPWLW  >I>FQ@AFZRR_QCDM^ @W>I>>>RAZW@][ZQSk@_kALNAZZRR_QCDM^ @W>>O>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @WHHsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @WFQ@AFZRR_QCDM^ @W>]Rsx{vuxgokkGWRkQDZV_kiRR_QCDM^ @W		hLRhLVFQ@AFZRR_QCDM^ @W>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W FQ@AFZRUXGQ>Y]UPYP\MRk	tsx{vuxgokkGWRk[RP^kXQF \[Ekibsx{vuxgokkGWRkQDZV_kiRR_QCDM^ @WLL>Y]UPYP\MRk	sx{vuxgokkGWRkWBSB\_k iY]UPYP\MRkY]UPYP\MRkoi>]RY]UPYP\MRk HHY]UPYP\MRk
FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>AYP BG^ B	tSNPQW[PQRR_QCDM^ @W>]RAYP BG^ B		RUXGQFQ@AFZAYP BG^ B>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>AYP BG^ B	tSN]ZRXU@Qsx{vuxgokkGWRkQDZV_kiRR_QCDM^ @Wjsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W  L VLV UQ>FQ@AFZsx{vuxgokkGWRkCGC  VMVVk iAYP BG^ Bsx{vuxgokkGWRkD@WYYENNCMMkkiAYP BG^ B	  AYP BG^ BRUXGQ>I>FQ@AFZRUXGQ>I>RAZW@][Z]GYVYYEFRPNR\AGY\]XRN^V>>O>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZsx{vuxgokkGWRkPSUX ]D\YCDki\AGY\]XRN^V>]Rsx{vuxgokkGWRkCGC  VMVVk i\AGY\]XRN^VHHsx{vuxgokkGWRkD@WYYENNCMMkki\AGY\]XRN^V		O>FQ@AFZRUXGQ>>>I>FQ@AFZsx{vuxgokkGWRkRYPXC^kMkEFkiRS^]Q]]ZB@[U\AGY\]XRN^V>>>I>>>RAZW@][ZP[SC\_^CNZQR^SR@>O>ZQ_ENY@_MGQLR	UFFUM>\QXBB@Z	UFFUMuvgdu`|uvgdu`|RS^]Q]]ZB@[Uuvgdu`|NWCUNEM>]RPQR]ZQPC[Q BXU \QXBB@Zoi	cdkw{z`qz`kp}f>>>R[FQUW\\QXBB@ZUGAYP BG^ BO>ZEX_RLMUM C	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  tsx{vuxgokkGWRkV^E_YEEGLMVkiAYP BG^ BRS^]Q]]ZB@[URUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iZEX_RLMUM CO>R[FQUW\ZEX_RLMUM CUG@WS\XZ[QkO>CkkWEWYZ_	tsx{vuxgokkGWRkUMX_NCYCki@WS\XZ[Qk>]RCkkWEWYZ_CkkWEWYZ_
LPWVLRVUVO>ZQ_ENY@_MGQLRoi	CkkWEWYZ_>I>I>I>I>]RQYD@MZQ_ENY@_MGQLRO>M YGAF^PE@ZQB	ZQ_ENY@_MGQLRosx{vuxgokkGWRkQZYQLXF\kiZQ_ENY@_MGQLRi>FQ@AFZM YGAF^PE@ZQBM YGAF^PE@ZQB ^@U[FB_S@YGNYEL>>>>I>S@A	sx{vuxgokkGWRkNWYM^SkLZ[BNki>ZGNRPQR_	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUCDkFUZPLUL  sx{vuxgokkGWRkWR_^N]^_ki>M YGAF^PE@ZQB	S@AZGNRPQR_>FQ@AFZM YGAF^PE@ZQBM YGAF^PE@ZQB^@U[FB_S@YGNYEL>>I>RAZW@][Z_FBEALFSD\G]GA_BDAVX\kVY[>O>]RQYD@Msx{vuxgoXSDQk^Y[_N[ iFQ@AFZBDAVX\kVY[>SRBQD^[WQQPN	sx{vuxgoC[Q BXUisx{vuxgokkGWRkPX^@X\kki@FAQ>>>>]RSRBQD^[WQQPNFQ@AFZRUXGQ>>FQ@AFZBDAVX\kVY[
SRBQD^[WQQPN]Z@sx{vuxgokkGWRk_PCV@ QNUkiSRBQD^[WQQPNBDAVX\kVY[>I>RAZW@][ZMLRQBGXLLQXSS@LDZEPEW[[BDAVX\kVY[S ZkCZ@M	ZAXX>O>BDAVX\kVY[	_FBEALFSD\G]GA_BDAVX\kVY[>]RBDAVX\kVY[			RUXGQFQ@AFZRUXGQ>>>>VCECPQLRMQ [G	RAZW@][ZXG_QLkAW@D\UBAAGQS ZkCZ@MO>]Rsx{vuxgokkGWRkCGC  VMVVk iXG_QLkAW@D\UBAHHXG_QLkAW@D\UBA			FQ@AFZRUXGQ>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiXG_QLkAW@D\UBA
    FQ@AFZRUXGQ>>>]RS ZkCZ@MO>@FMO>FQ@AFZV[[Xsx{vuxgokkGWRk_[B\CCNMkiS ZkCZ@MXG_QLkAW@D\UBA>>IWU@W\`\F[CUVXQ[GD[EZLNO>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>FQ@AFZRUXGQ>>>I>I>FQ@AFZ@FAQ>I>ZWE]AFQ]XQ	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtsx{vuxgokkGWRkVkFMXL ki@LDZEPEW[[UFFUM>RS^]Q]]ZB@[U 	
BDAVX\kVY[>NWCUNEM	
RUXGQ>NWCUNEM	
>>RUXGQ>>>>]RZWE]AFQ]XQsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NHH]GkCDkQFF[FZWE]AFQ]XQO>]R]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQZWE]AFQ]XQ			LLVO>>EW@DVSBFS\	CDkFQY[@QkFQ@F]QBQkV[PMZWE]AFQ]XQ>>]RVCECPQLRMQ [GEW@DVSBFS\FQ@AFZEW@DVSBFS\>I>I>BDAVX\kVY[	_FBEALFSD\G]GA_BDAVX\kVY[>>>>]RBDAVX\kVY[			RUXGQFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>PP AEENAWkX	tsx{vuxgokkGWRkDWXZ_A^Vki@LDZEPEW[[>]RPP AEENAWkX			RUXGQFQ@AFZRUXGQ>tsx{vuxgokkGWRkCDZGEE [kiPP AEENAWkXUFFUM>W[ZG@UZ@YLW ^L@N	
@FAQ>W[ZG@UZ@XSDQk^Y[_N[ 	
BDAVX\kVY[>W[ZG@UZ@U_GSMD@V 	
RUXGQ>>>>W[ZG@UZ@RS^]Q]]ZB@[U	
>W[ZG@UZ@NWCUNEM	
RUXGQ>W[ZG@UZ@NWCUNEM	
RAZW@][ZNENDELUZDQD^Z\BC[Rk]VWMV\_CUkBCA\kO>FQ@AFZ_CUkBCA\k
  >I>>XXk^[U	tsx{vuxgokkGWRkYC]kWZY^QkiPP AEENAWkX>ZQGMBD\QZ	tWAFXkQFFZ[PP AEENAWkX>FkLA_Y Ak^QG\	tWAFXkSQ@]ZR[PP AEENAWkX>tWAFXkWX[GQPP AEENAWkX>]RZQGMBD\QZFQ@AFZRUXGQ>]R]Z@FkLA_Y Ak^QG\oYLW ^L@Ni			 XXk^[U		RUXGQVCECPQLRMQ [GXXk^[UO>>>FQ@AFZXXk^[U>I>I>FQ@AFZRUXGQ>I>>RAZW@][ZWZLSB]YNVRG^VXPF]PA@LDZEPEW[[PR_kSRMADLYXBB @A \WQRBDAVX\kVY[S ZkCZ@M	ZAXX>O>BDAVX\kVY[	_FBEALFSD\G]GA_BDAVX\kVY[>]RBDAVX\kVY[			RUXGQFQ@AFZRUXGQ>VCECPQLRMQ [G	RAZW@][ZXG_QLkAW@D\UBAAGQS ZkCZ@MO>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iXG_QLkAW@D\UBAHHXG_QLkAW@D\UBA			FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiXG_QLkAW@D\UBA
FQ@AFZRUXGQ>]RS ZkCZ@MO>@FMO>FQ@AFZV[[Xsx{vuxgokkGWRk_[B\CCNMkiS ZkCZ@MXG_QLkAW@D\UBA>>>IWU@W\`\F[CUVXQ[GD[EZLNO>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>FQ@AFZRUXGQ>I>I>FQ@AFZ@FAQ>I>ZWE]AFQ]XQ	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtsx{vuxgokkGWRk@U@@BYER]Ski@LDZEPEW[[UFFUM>U_GSMD@V 	
BDAVX\kVY[>XSDQk^Y[_N[ 	
RUXGQ>YLW ^L@N	
LW LQVQ>YLW ^L@N	
DLYXBB @A \WQR>RS^]Q]]ZB@[U	
PR_kSRMA>RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N]GkCDkQFF[FZWE]AFQ]XQO>IQXGQ]RZWE]AFQ]XQO>Y@Z[D[X	]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQZWE]AFQ]XQ>P FWXRW 	CDkFQY[@QkFQ@F]QBQkV[PMZWE]AFQ]XQ>NAEB	CDkFQY[@QkFQ@F]QBQk\QUPQFGZWE]AFQ]XQ>A\ B RF^U	>]Rsx{vuxgokkGWRkWBSB\_k iNAEBO>R[FQUW\NAEBUGCPF]\AUC	
QGPF XFCLW]_O>>>A\ B RF^U	CPF]\AUCRS^]Q]]ZB@[UQGPF XFCLW]_XSDQk^Y[_N[ >I>I>]RY@Z[D[X			L RLVCECPQLRMQ [GP FWXRW O>FQ@AFZP FWXRW >I>IQXGQO>I>]RQYD@Msx{vuxgoRS^]Q]]ZB@[U iFQ@AFZRUXGQ>BDAVX\kVY[	_FBEALFSD\G]GA_BDAVX\kVY[>>]RBDAVX\kVY[			RUXGQFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VO>PP AEENAWkX	tsx{vuxgokkGWRkDWXZ_A^Vki@LDZEPEW[[>]RPP AEENAWkX			RUXGQO>FQ@AFZRUXGQ>I>Rk]XUEA[Pk	UFFUM>R[FQUW\DLYXBB @A \WQRUGCPF]\AUC	
QGPF XFCLW]_O>Rk]XUEA[Pkoi	CPF]\AUCNWCUNEMQGPF XFCLW]_>I>>>tsx{vuxgokkGWRkCDZGEE [kiPP AEENAWkXUFFUM>>>W[ZG@UZ@XSDQk^Y[_N[ 	
@FAQ>>>>W[ZG@UZ@RS^]Q]]ZB@[U	
PR_kSRMA>W[ZG@UZ@XSDQk^Y[_N[ 	
@FAQ>>>W[ZG@UZ@RS^]Q]]ZB@[U	
BDAVX\kVY[>>W[ZG@UZ@C[Q BXU 	
RUXGQ>W[ZG@UZ@RS^]Q]]ZB@[U	
>W[ZG@UZ@RS^]Q]]ZB@[U	
Rk]XUEA[Pk>W[ZG@UZ@C[Q BXU	
RUXGQ>W[ZG@UZ@YLW ^L@N	
RAZW@][ZNENDELUZDQD^Z\BC[Rk]VWMV\_CUkBCA\kO>FQ@AFZ_CUkBCA\k
 >>>I>>XXk^[U	tsx{vuxgokkGWRkYC]kWZY^QkiPP AEENAWkX>>>ZQGMBD\QZ	tWAFXkQFFZ[PP AEENAWkX>BLQUVMCVLQZBL	tWAFXkQFF[FPP AEENAWkX>FkLA_Y Ak^QG\	tWAFXkSQ@]ZR[PP AEENAWkX>kEVLWM^	]Z@FkLA_Y Ak^QG\oC[Q BXUi>>]RZQGMBD\QZO>tWAFXkWX[GQPP AEENAWkX>>>>FQ@AFZRUXGQ>I>>>tWAFXkWX[GQPP AEENAWkX>]RkEVLWM^			XXk^[U		RUXGQVCECPQLRMQ [GXXk^[UO>FQ@AFZXXk^[U>I>]RXXk^[UO>I>>FQ@AFZRUXGQ>I>FQ@AFZRUXGQ>I>>RAZW@][Z\^@L\ EG_\CXQRFZ\PG@[	 >O>RSFFFAkQ[^ZB	Lk_@Y ZRB]][LD VZY]>DL\G_YD_RE\	MDU[^WVEZSEkNXZV]\>CXQRFZ\PG@[	]Z@CXQRFZ\PG@[>>>]RCXQRFZ\PG@[LLCXQRFZ\PG@[	 >]RCXQRFZ\PG@[
CXQRFZ\PG@[	j >>]RQYD@MRSFFFAkQ[^ZBHHQYD@MDL\G_YD_RE\O>FQ@AFZUFFUM>I>>\k@N@QBCNS_	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM  G@F]ZSSQ@k[D@][ZRS^]Q]]ZB@[U>>]R\k@N@QBCNS_		sx{vuxgokkGWRkUFBG[ZLZN Gk i\k@N@QBCNS_DL\G_YD_RE\@FAQ\k@N@QBCNS_	>]R\k@N@QBCNS_		O>DL\G_YD_RE\	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRkk\SZ\YY kiDL\G_YD_RE\UFFUM\k@N@QBCNS_>sx{vuxgokkGWRkF[MVXEDMMXR]kiDL\G_YD_RE\\k@N@QBCNS_>>I>>M\V\\[DR	sx{vuxgokkGWRk\G[ML]GWkiRSFFFAkQ[^ZBosx{vuxgokkGWRkQZYQLXF\kiRSFFFAkQ[^ZBi>]RM\V\\[DR			O>>FQ@AFZUFFUM>I>>PR_kSRMA	RS^]Q]]ZB@[UM\V\\[DRU_GSMD@V>S]Ek[YARE	UFFUMYLW ^L@N 	
C[Q BXU>Y]RFL^BUkB	sx{vuxgokkGWRkPX^@X\kki@FAQ>R[FQUW\DL\G_YD_RE\UGXZ FCD\[UQEZEO>>>>>]Rsx{vuxgokkGWRkPX^@X\kki@FAQY]RFL^BUkB
CXQRFZ\PG@[O>VFQU_>I>>XZ FCD\[UQEZE	sx{vuxgokkGWRk\G[ML]GWkiG@F]ZSXZ FCD\[UQEZE>]RXZ FCD\[UQEZE			O>W[Z@]ZAQ>I>@FMO>P FWXRW 	WZLSB]YNVRG^VXPF]PAXZ FCD\[UQEZEPR_kSRMAS]Ek[YAREjRAZW@][ZXG_QLkAW@D\UBAO>ZULN Z] [@E	tsx{vuxgokkGWRkWL[M\VYkiXG_QLkAW@D\UBA@FAQ>FQ@AFZsx{vuxgokkGWRkWBSB\_k iZULN Z] [@E]GGQ@ZULN Z] [@EoYLW ^L@Ni>>>I>]RP FWXRW 			RUXGQO>W[Z@]ZAQ>I>UB^@@BSM	tsx{vuxgokkGWRkWL[M\VYkiP FWXRW @FAQ>]Rsx{vuxgokkGWRkWBSB\_k iUB^@@BSMHH]GGQ@UB^@@BSMoRS^]Q]]ZB@[UiHHsx{vuxgokkGWRkCGC  VMVVk iUB^@@BSMoU_GSMD@ViO>W[Z@]ZAQ>>I>>\AGY\]XRN^V	UB^@@BSMoXSDQk^Y[_N[ i>]Rsx{vuxgokkGWRkUAU[DUV]kWki\AGY\]XRN^VNWCUNEM			O>>>>\AGY\]XRN^V	sx{vuxgokkGWRkQDZV_ki\AGY\]XRN^V>I>>_CCGBQE\	t]GYVYYEFRPNR\AGY\]XRN^V>]R_CCGBQE\			RUXGQHHsx{vuxgokkGWRkD@WYYENNCMMkki_CCGBQE\ jO>W[Z@]ZAQ>I>>>>[NSEEBMXM@N	 >>>k\ZML^[ELk	sx{vuxgokkGWRkQ[RLZY]CFk[ki_CCGBQE\o[NSEEBMXM@Ni>_DZRB@WF	sx{vuxgokkGWRkQDZV_ki_CCGBQE\[NSEEBMXM@Nk\ZML^[ELk>]Rsx{vuxgokkGWRkCGC  VMVVk i_DZRB@WFHHsx{vuxgokkGWRkD@WYYENNCMMkki_DZRB@WFO>W[Z@]ZAQ>I>>>>>Y[DWWN@	sx{vuxgokkGWRkQ[RLZY]CFk[ki_DZRB@WFoi>]RY[DWWN@HHsx{vuxgokkGWRkD@WYYENNCMMkki_DZRB@WFY[DWWN@O>W[Z@]ZAQ>>>>I>>]]V]_@ALZ\MEFS	sx{vuxgokkGWRkQDZV_ki_DZRB@WFY[DWWN@>PFLDAGPkDYDM	sx{vuxgokkGWRkQDZV_ki_DZRB@WFY[DWWN@>]Rsx{vuxgokkGWRkCGC  VMVVk i]]V]_@ALZ\MEFSHHsx{vuxgokkGWRkCGC  VMVVk iPFLDAGPkDYDMO>W[Z@]ZAQ>I>>>>>>CAAAQ_	RPSR]FXSNC^E@PFLDAGPkDYDM]]V]_@ALZ\MEFS>]Rsx{vuxgokkGWRkCGC  VMVVk iCAAAQ_HHsx{vuxgokkGWRkD@WYYENNCMMkkiCAAAQ_O>>>>[]\CNNBEZB[Q\APGC[Q BXUYLW ^L@N >W[Z@]ZAQ>>>>I>>]_SUMXUX\[F	sx{vuxgokkGWRkQ[RLZY]CFk[kiCAAAQ_oi>]R]_SUMXUX\[FHHsx{vuxgokkGWRkD@WYYENNCMMkkiCAAAQ_]_SUMXUX\[FO>[]\CNNBEZB[Q\APGC[Q BXUYLW ^L@N>W[Z@]ZAQ>I>>>>>N\NQWFMW^	sx{vuxgokkGWRkQDZV_kiCAAAQ_]_SUMXUX\[F>YYU DAU_@GYQ	sx{vuxgokkGWRkQDZV_kiCAAAQ_]_SUMXUX\[F>ZkMZ W@	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRk\QX@@RVGD kisx{vuxgokkGWRkEZVQ\Y]LBkiRS^]Q]]ZB@[Usx{vuxgokkGWRkRXGEDZ]QkiRS^]Q]]ZB@[UYYU DAU_@GYQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>ADPU@Qk[D@][ZU_GSMD@VXZ FCD\[UQEZE>ADPU@Qk[D@][ZRS^]Q]]ZB@[Usx{vuxgokkGWRkP P\XE _DFNAk ihZZkMZ W@>I>>>>FQ@AFZUFFUMNWCUNEM 	
N\NQWFMW^XSDQk^Y[_N[  	
ZkMZ W@>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>W[Z@]ZAQ>IWU@W\qLWQD@][Z[GD[EZLNO>W[Z@]ZAQ>I>I>^ @CVYME[	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[   G@F]ZSSQ@k[D@][ZU_GSMD@V>GZWQPGSFU	M_E@QREC][U_GSMD@V >]R^ @CVYME[		sx{vuxgokkGWRkCGC  VMVVk iGZWQPGSFUGZWQPGSFU		O>ZkMZ W@	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRk\QX@@RVGD kisx{vuxgokkGWRkEZVQ\Y]LBkiYLW ^L@N  sx{vuxgokkGWRkRXGEDZ]QkiRS^]Q]]ZB@[U ^ @CVYME[>]RQYD@MZkMZ W@O>FQ@AFZUFFUMRS^]Q]]ZB@[U 	
GZWQPGSFUYLW ^L@N 	
ZkMZ W@>I>I>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U NWCUNEM >FQ@AFZUFFUM>I>RAZW@][ZDUCXUFUD^kQX_RE^PELQPM[XND@CNBFFLC^[VR]D>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>FQ@AFZRUXGQ>I>>>]R]GGQ@sx{vuxgoNWCUNEM isx{vuxgokkGWRkWBSB\_k isx{vuxgoYLW ^L@Nisx{vuxgokkGWRkVQRVVAQZLk i_RE^PELQPsx{vuxgoXSDQk^Y[_N[ iO>AZGQ@sx{vuxgoU_GSMD@Vio_RE^PELQPi>>I>>^FX@FL[Mk_Q^	sx{vuxgokkGWRkS[G]P_P[ZkiM[XND@C>CV_ZANGL_YD	sx{vuxgokkGWRkYWPCDD@Ukisx{vuxgokkGWRkLFUXCD_ k ij>ZPYML@XGQE	>>>>R[FF^P_ NFVB	W_^PAWE_LF	sx{vuxgokkGWRkD@WYYENNCMMkki^FX@FL[Mk_Q^F^P_ NFVBW_^PAWE_LFF^P_ NFVBO>ZPYML@XGQE	sx{vuxgokkGWRkYWPCDD@Ukisx{vuxgokkGWRkQ[RLZY]CFk[ki^FX@FL[Mk_Q^oF^P_ NFVBijsx{vuxgokkGWRkQ[RLZY]CFk[kiCV_ZANGL_YD>I>FQ@AFZADPU@Qk[D@][Z_RE^PELQPsx{vuxgokkGWRkV\W][LkiCV_ZANGL_YDZPYML@XGQENBFFLC^[VR]D		RUXGQ>I>>RAZW@][ZBNGBN E@XYFNMSB_RE^PELQPR^WQEERF\VVZXC>>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  FQ@AFZR^WQEERF\VVZXC>]R]GGQ@sx{vuxgoC[Q BXUisx{vuxgokkGWRkWBSB\_k isx{vuxgoU_GSMD@Visx{vuxgokkGWRkVQRVVAQZLk i_RE^PELQPsx{vuxgoRS^]Q]]ZB@[UiO>FQ@AFZsx{vuxgoC[Q BXUio_RE^PELQPi>I>X VC DkDP	SQ@k[D@][Z_RE^PELQP>]RX VC DkDP			HHsx{vuxgokkGWRkCGC  VMVVk iX VC DkDPO>>>>FQ@AFZR^WQEERF\VVZXC>I>]_QRV_UN]]	tsx{vuxgokkGWRkWBDQ[VVAZE\kiX VC DkDP@FAQ>]R]_QRV_UN]]			RUXGQHHsx{vuxgokkGWRkD@WYYENNCMMkki]_QRV_UN]]O>FQ@AFZR^WQEERF\VVZXC>I>CV_ZANGL_YD	]_QRV_UN]]oi>ZSMW]@S[L	>R[FF^P_ NFVB	W_^PAWE_LF	sx{vuxgokkGWRkD@WYYENNCMMkki]_QRV_UN]]F^P_ NFVBW_^PAWE_LFF^P_ NFVBO>ZSMW]@S[L	sx{vuxgokkGWRkYWPCDD@Ukisx{vuxgokkGWRkQ[RLZY]CFk[ki]_QRV_UN]]oF^P_ NFVBijsx{vuxgokkGWRkQ[RLZY]CFk[kiCV_ZANGL_YD>I>D\PUGLDR 	BQF@[YVS[USFV@ZSMW]@S[L>]RD\PUGLDR 		RUXGQO>>>>]R]GGQ@sx{vuxgoNWCUNEMiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoC[Q BXUisx{vuxgoU_GSMD@Vi	UFFUM>]Rsx{vuxgokkGWRkEMVLY\Akisx{vuxgoRS^]Q]]ZB@[Ui
sx{vuxgoRS^]Q]]ZB@[Ui	UFFUM>sx{vuxgoU_GSMD@Vio_RE^PELQPi	D\PUGLDR >FQ@AFZD\PUGLDR >>I>FQ@AFZR^WQEERF\VVZXC>I>>>>RAZW@][ZBQF@[YVS[USFV@_DZRB@WF>O>]Rsx{vuxgokkGWRkCGC  VMVVk i_DZRB@WFFQ@AFZRUXGQ>]RPQR]ZQPU_GSMD@Vd|dkbqfg}{zk}p
	 O>FQ@AFZtsx{vuxgokkGWRkAEN_kX]@W ki_DZRB@WFUFFUMC[Q BXU	
RUXGQ>>>>I>FQ@AFZtsx{vuxgokkGWRkAEN_kX]@W ki_DZRB@WF>I>RAZW@][ZLN]M^MWME[P>O>G@U@]WCPF]\AUC	ZAXX>]RCPF]\AUC		ZAXXFQ@AFZCPF]\AUC>LUkFX_AZZZFQ	PQR]ZQPC[Q BXUuvgdu`|>CPF]\AUC	sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkR_]RRR^ ESkihhLUkFX_AZZZFQ>FQ@AFZCPF]\AUC>I>>RAZW@][ZFLQWZ ED P _RE^PELQP>O>FQ@AFZSL@D ]FAVZLN]M^MWME[PG@F]ZS^@U[FB_S@YGNYEL_RE^PELQP>>>>I>RAZW@][ZNBUZPGUYBEXCFZDNZGCZGB>>>O>FQ@AFZG@F]ZS]Z@\QLPQWsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiLN]M^MWME[PXSDQk^Y[_N[ FZDNZGCZGB >>>I>RAZW@][ZE[NSB\PRB@X^_[WA[Z>O>FQ@AFZNBUZPGUYBEXCU_GSMD@V >I>RAZW@][ZL@PXLU]RYZ>O>]RAXEZFV	G@F]ZSM_E@QREC][C[Q BXU>>FQ@AFZsx{vuxgokkGWRkD@WYYENNCMMkki]RAXEZFV
L Lsx{vuxgokkGWRkUAU[DUV]kWki]RAXEZFVE[NSB\PRB@X^_[WA[Z		RUXGQsx{vuxgokkGWRkD@WYYENNCMMkkiG@F]ZSM_E@QREC][YLW ^L@N
>I>>RAZW@][ZM_E@QREC][_RE^PELQPR^WQEERF\VVZXC>O>>FQ@AFZBNGBN E@XYFNMSBFLQWZ ED P _RE^PELQPR^WQEERF\VVZXC>I>RAZW@][ZkP^D_FS\YY W_RE^PELQPR^WQEERF\VVZXC	>O>>>>QGPF XFCLW]_	M_E@QREC][_RE^PELQPR^WQEERF\VVZXC>]Rsx{vuxgokkGWRkCGC  VMVVk iQGPF XFCLW]_FQ@AFZQGPF XFCLW]_>]Rsx{vuxgokkGWRkYU[D]PXC]MQkiQGPF XFCLW]_FQ@AFZG@F]ZSQGPF XFCLW]_>FQ@AFZR^WQEERF\VVZXC>>I>>RAZW@][ZYSWP_GN@FXX_RE^PELQPM[XND@CNBFFLC^[VR]D>O>FQ@AFZDUCXUFUD^kQXFLQWZ ED P _RE^PELQPM[XND@CNBFFLC^[VR]D>I>RAZW@][ZVX[^CB]BANBDSFBQXN>O>kUUNW_FZ	]GGQ@sx{vuxgoC[Q BXUisx{vuxgoXSDQk^Y[_N[ iUFFUM>X VC DkDP	M_E@QREC][U_GSMD@VUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iX VC DkDPO>kUUNW_FZ	sx{vuxgokkGWRkPE\P] W]XPFFAkiX VC DkDPkUUNW_FZ>I>kUUNW_FZ	sx{vuxgokkGWRk_SM[G_FkLFk ikUUNW_FZ>>>>FQ@AFZsx{vuxgokkGWRkXY\ECNkLB^@kikUUNW_FZLRL>I>>>>RAZW@][ZG@APS MCDVQYL^LPGXP>>>>O>]R]GGQ@sx{vuxgoRS^]Q]]ZB@[UiHHQYD@Msx{vuxgoNWCUNEMiFQ@AFZ>@FMO>X VC DkDP	M_E@QREC][YLW ^L@NUFFUM>>>A^AkXL_\XM	sx{vuxgokkGWRk_SM[G_FkLFk isx{vuxgokkGWRkPE\P] W]XPFFAkiUFFUMX VC DkDPsx{vuxgoYLW ^L@Ni>A^AkXL_\XM	sx{vuxgokkGWRkXY\ECNkLB^@kiA^AkXL_\XM>YSWP_GN@FXXC[Q BXUA^AkXL_\XMRS^]Q]]ZB@[U>>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>RAZW@][ZRPSR]FXSNC^E@_DZRB@WF_QM>O>]Rsx{vuxgokkGWRkCGC  VMVVk i_DZRB@WFHHsx{vuxgokkGWRkCGC  VMVVk i_QMHHsx{vuxgokkGWRkD@WYYENNCMMkki_QM			O>FQ@AFZZAXX>I>L_CWV	sx{vuxgokkGWRkD@WYYENNCMMkki_DZRB@WF>A[BXSN\ Q@	sx{vuxgokkGWRkD@WYYENNCMMkki_QM>>>\MkR ADAkL[S	>R[FF^P_ NFVB	F^P_ NFVBL_CWVF^P_ NFVBO>\MkR ADAkL[S	sx{vuxgokkGWRkYWPCDD@Ukisx{vuxgokkGWRkQ[RLZY]CFk[ki_DZRB@WFoF^P_ NFVBijsx{vuxgokkGWRkQ[RLZY]CFk[ki_QMoF^P_ NFVBA[BXSN\ Q@i>I>FQ@AFZ\MkR ADAkL[S>I>>>>RAZW@][Z_[kB ]ZDBUDQVAUFN]\LAFMANAW>O>]Rsx{vuxgokkGWRkWBSB\_k iUFN]\LAFMANAWO>UFN]\LAFMANAW	UFFUM>I>G@U@]WZC_XXFQYQB	ZAXX>]RZC_XXFQYQB			ZAXXO>ZC_XXFQYQB	XR@SBMF[\@XR>>\U^L A[FUBYXY	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  BNGBN E@XYFNMSBNWCUNEMRUXGQRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k i\U^L A[FUBYXY]GGQ@\U^L A[FUBYXYoXSDQk^Y[_N[  i]Z@\U^L A[FUBYXYoC[Q BXU i
	 ]Z@\U^L A[FUBYXYoNWCUNEM i	ZC_XXFQYQB	]Z@\U^L A[FUBYXYoRS^]Q]]ZB@[U i>]RZC_XXFQYQBLLO>ZC_XXFQYQB	 >I>I>UFN]\LAFMANAWoC[Q BXUi	UFFUM>RS^]Q]]ZB@[U	
ZC_XXFQYQB>>>>XSDQk^Y[_N[ 	
NWCUNEM>>UFN]\LAFMANAWoC[Q BXUi	UFFUM>XSDQk^Y[_N[ 	
>NWCUNEM	
XSDQk^Y[_N[ >>>>>FQ@AFZUFN]\LAFMANAW>I>>RAZW@][ZRW_VBDDPP[]EME>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUHHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZ>]RPZEURB[UWFUPC[Q BXUFQ@AFZ>@FMO>>]RCDkZQL@kGW\QPAXQPY]BFFRNL@_MGA^O>>CDkGW\QPAXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNkisx{vuxgokkGWRkLFUXCD_ k iLL LLXSDQk^Y[_N[ Y]BFFRNL@_MGA^>>>I>IR]ZUXXMO>>>>L^U[US^\kM^C[Q BXU>I>>>I>>>>>>RAZW@][ZB]]ZZYZRWVDYCR\AY>O>>]RPQR]ZQPNWCUNEM p{}zskwf{zO>FQ@AFZ>I>>G@U@]WRYCD]kCCSNU	RUXGQ>]RRYCD]kCCSNUFQ@AFZ>RYCD]kCCSNU	@FAQ>>]RNCEYDFYSUkFBUFXGUYO>FQ@AFZ>I>>>VMR^VBCUFWXDYLW ^L@NXSDQk^Y[_N[ >I>RAZW@][ZPCCU\BR^]PYG@kU>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZ>>>tsx{vuxgokkGWRkVkFMXL kiG]@QkAFXC[Q BXUsx{vuxgokkGWRkR_]RRR^ ESkiG@F]ZSsx{vuxgokkGWRkPX^@X\kki@FAQsx{vuxgokkGWRkLFUXCD_ k iLLPL RLUFFUMC[Q BXU	
XSDQk^Y[_N[ 	
RUXGQXSDQk^Y[_N[ 	
RUXGQ>I>RAZW@][ZZUD^M]ZW[ UVG>O>G@U@]WSNBURk]]NAL	RUXGQ>]RSNBURk]]NALFQ@AFZ>SNBURk]]NAL	@FAQ>@FMO>>FZUkVNAGASLWPF^XUU>>>EXA_Gk^	RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>sx{vuxgokkGWRkZ^QDVBUV_FRki>EXA_Gk^	@FAQ>IQXGQ]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>sx{vuxgokkGWRk^]XY^D VSM Vk i>>>EXA_Gk^	@FAQ>>>IQXGQO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>tsx{vuxgokkGWRkGBYDVWBARCki@FAQ>I>AXADRPSV	RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>SCkC@DGNGC	sx{vuxgokkGWRkX@FXkisx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkQZNVM]LkiNWCUNEM>AXADRPSV	SCkC@DGNGC		SCkC@DGNGC		SCkC@DGNGC		C[Q BXU>I>A\WSMF[EC	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[VkSQ@kG@U@AG@FAQUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iA\WSMF[ECO>R[FQUW\A\WSMF[ECUGRD]]BAX[F O>Y]RkM AXZE	sx{vuxgokkGWRkWBSB\_k iRD]]BAX[F ]GGQ@RD]]BAX[F oYLW ^L@N isx{vuxgokkGWRkX@FXkiG@F]ZSRD]]BAX[F oC[Q BXU i>>>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiY]RkM AXZENWCUNEM 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiY]RkM AXZENWCUNEM 		RUXGQO>AXADRPSV	@FAQ>VFQU_>I>I>I>]RAXADRPSVsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>R[FQUW\UFFUMt\QUPQFGkX]G@UGUPFDDCEF[EBQO>]RG@F]D[GUPFDDCEF[EBQNWCUNEM  			G@F]D[GUPFDDCEF[EBQU_GSMD@V 			RUXGQO>AXADRPSV	@FAQ>VFQU_>>>>I>>>I>>>>I>MQG^EWYN	sx{vuxgokkGWRkLEG\G\DMQADki>^CLVWNN\	MQG^EWYN		C[Q BXU MQG^EWYN		RS^]Q]]ZB@[U >EPEQE^DWk	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V ]Z@t\@@DkFQGD[ZGQkW[PQ>_Y\_ADSWU	EPEQE^DWk
	LLEPEQE^DWkLPLUVHHEPEQE^DWk			L  LHHEPEQE^DWk			 >WVLL^^CWZkV_	]GGQ@kgqfbqfoNWCUNEM ikgqfbqfoU_GSMD@V i			XSDQk^Y[_N[  >B[NXDFVGB R	RUXGQ>]R^CLVWNN\_Y\_ADSWUWVLL^^CWZkV_\QUPQFGkGQZ@AXADRPSVO>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
O>Q^EGLDP]WZU	sx{vuxgokkGWRk\^DUBFDPYUDk i>>>]Rtsx{vuxgokkGWRk_A\[@WSAVk iHHsx{vuxgokkGWRk\^DUBFDPYUDk i
	Q^EGLDP]WZUVFQU_>>>>I>RD]]BAX[F 	sx{vuxgokkGWRk\^DUBFDPYUDk i			sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ t[VkSQ@kG@U@AGUFFUM>>>Y]RkM AXZE	sx{vuxgokkGWRkWBSB\_k iRD]]BAX[F ]GGQ@RD]]BAX[F oC[Q BXU isx{vuxgokkGWRkX@FXkiG@F]ZSRD]]BAX[F oXSDQk^Y[_N[  i>kWX	RUXGQ>]Rsx{vuxgokkGWRk\^DUBFDPYUDk i			O>kWX	>IQXGQ]R>sx{vuxgokkGWRk\^DUBFDPYUDk i			>sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM>>>>Y]RkM AXZE			HHY]RkM AXZE			U_GSMD@V  >sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N >O>kWX	t[VkSQ@kXQZS@\>I>[MQVVD^CS	@FAQ>]R]GGQ@sx{vuxgoC[Q BXU ioU_GSMD@V iO>kCR	sx{vuxgoRS^]Q]]ZB@[U ioYLW ^L@N i>@EYWG[RZ_ZU	sx{vuxgokkGWRk@L\SQY@ZAkikCR]GGQ@kCR
WUXXVUW_GkCR
WUXXVUW_Gsx{vuxgokkGWRkWBSB\_k ikCRkCRUFFUM>R[FQUW\@EYWG[RZ_ZUUGkDF	
WkNL@F^DMXNVO>]Rsx{vuxgokkGWRkWBSB\_k iWkNL@F^DMXNVW[Z@]ZAQ>>>>R[FQUW\WkNL@F^DMXNVUG\\^WNCFGO>D]ZCM_AR	sx{vuxgokkGWRkWBSB\_k i\\^WNCFG]GGQ@\\^WNCFGoNWCUNEM i\\^WNCFGoYLW ^L@N i>>]Rsx{vuxgokkGWRkCGC  VMVVk iD]ZCM_ARsx{vuxgokkGWRkUFBG[ZLZN Gk iD]ZCM_ARUFFUMXSDQk^Y[_N[ XSDQk^Y[_N[  @FAQW[Z@]ZAQ>[MQVVD^CS	RUXGQ>>>>VFQU_>I>I>AZGQ@kCR@EYWG[RZ_ZUkDFWkNL@F^DMXNV\\^WNCFGD]ZCM_AR>I>>]RkWX		RUXGQ[MQVVD^CS\QUPQFGkGQZ@O>t\QUPQFC[Q BXU ]Z@kWX>t\QUPQFU_GSMD@V >B[NXDFVGB R	@FAQ>I>I>]R^CLVWNN\O>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
O>>>>Q^EGLDP]WZU	sx{vuxgokkGWRk\^DUBFDPYUDk i>]Rtsx{vuxgokkGWRk_A\[@WSAVk iHHsx{vuxgokkGWRk\^DUBFDPYUDk i
	Q^EGLDP]WZUVFQU_>I>tsx{vuxgokkGWRkGUQYEXRVQ\k i>I>]RB[NXDFVGB Rsx{vuxgokkGWRk\^DUBFDPYUDk i			EXA_Gk^	@FAQ>AZGQ@AXADRPSVSCkC@DGNGCA\WSMF[ECRD]]BAX[F Y]RkM AXZEUPFDDCEF[EBQMQG^EWYN^CLVWNN\EPEQE^DWk_Y\_ADSWUB[NXDFVGB RQ^EGLDP]WZUkWXWVLL^^CWZkV_>I>U^LAXFP__AM	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  PQR]ZQPU_GSMD@V p}guvxqkcdkwf{z>>>M@GL@G@EG	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  HH]Z@SQ@k[D@][ZU_GSMD@V 			>]RM@GL@G@EGsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V O>BDUBX^Q	G@F]ZSSQ@k[D@][ZC[Q BXU >]RBDUBX^Q		XCDS]V]N]\U[DX CO>tADPU@Qk[D@][ZYLW ^L@N XCDS]V]N]\U[DX CNWCUNEM>tADPU@Qk[D@][ZC[Q BXU C[Q BXU >M@GL@G@EG	@FAQ>I>I>[YWAEE\LD	RUXGQ>>>>]RU^LAXFP__AMsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>YN[_RFG_AR	CDkZQL@kGW\QPAXQPY]BFFRNL@_MGA^>]RYN[_RFG_ARsx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@YN[_RFG_AR
O>[YWAEE\LD	@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tCDkAZGW\QPAXQkQBQZ@]Z@YN[_RFG_ARY]BFFRNL@_MGA^>I>I>]RU^LAXFP__AMM@GL@G@EG[YWAEE\LDO>RM^M\A 	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U]Z@CDkZQL@kGW\QPAXQPY]BFFRNL@_MGA^>]RRM^M\A 	HHRM^M\A sx{vuxgokkGWRkNWYM^SkLZ[BNki
 O>tCDkGW\QPAXQkG]ZSXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNkiY]BFFRNL@_MGA^>I>N\]ZDXN kRPM>FQ@AFZ>>>I>>]R[YWAEE\LD[]\CNNBEZB[Q\APGC[Q BXU XSDQk^Y[_N[  >]REXA_Gk^O>>>]RU^LAXFP__AMO>tCDkGW\QPAXQkG]ZSXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNkiY]BFFRNL@_MGA^>>PCCU\BR^]PYG@kU>N\]ZDXN kRPM>FQ@AFZ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tsx{vuxgokkGWRkR_GC[[k\k i>>>>ZBN[WFDF\>FQ@AFZ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V tsx{vuxgokkGWRkR_GC[[k\k i  >ZBN[WFDF\>IWU@W\`\F[CUVXQ[GD[EZLNO>>>[]\CNNBEZB[Q\APGYLW ^L@N [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>I>>RAZW@][Z\N^PC_@DLR[FBFQGL>O>>>>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  O>FQ@AFZ>I>>>>>\_BFFQX[RWZNGk]	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V SQ@k@FUZG]QZ@DPAZGEVRQCQ_RUXGQ>]Rsx{vuxgokkGWRkWBSB\_k i\_BFFQX[RWZNGk]\_BFFQX[RWZNGk]	BNGBN E@XYFNMSBNWCUNEMRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k i\_BFFQX[RWZNGk]O>FQ@AFZ>I>>]R]GGQ@\_BFFQX[RWZNGk]oRS^]Q]]ZB@[U isx{vuxgokkGWRkWBSB\_k i\_BFFQX[RWZNGk]oXSDQk^Y[_N[  iO>sx{vuxgoU_GSMD@V i	\F^A^\ YFUAMALM]]\_BFFQX[RWZNGk]oYLW ^L@N i>I>>]R]GGQ@\_BFFQX[RWZNGk]oRS^]Q]]ZB@[U isx{vuxgokkGWRkWBSB\_k i\_BFFQX[RWZNGk]oYLW ^L@N iO>sx{vuxgoXSDQk^Y[_N[  i	\F^A^\ YFUAMALM]]\_BFFQX[RWZNGk]oXSDQk^Y[_N[   i>>>>I>>>]R]GGQ@\_BFFQX[RWZNGk]oRS^]Q]]ZB@[U  isx{vuxgokkGWRkCGC  VMVVk i\_BFFQX[RWZNGk]oC[Q BXU  iO>sx{vuxgoYLW ^L@N  i	\_BFFQX[RWZNGk]oRS^]Q]]ZB@[U  i>I>]R]GGQ@\_BFFQX[RWZNGk]oYLW ^L@N  isx{vuxgokkGWRkCGC  VMVVk i\_BFFQX[RWZNGk]oC[Q BXU  isx{vuxgokkGWRkD@WYYENNCMMkki\_BFFQX[RWZNGk]oYLW ^L@N  i
LWLO>sx{vuxgoRS^]Q]]ZB@[U   i	\_BFFQX[RWZNGk]oXSDQk^Y[_N[   i>I>]R]GGQ@\_BFFQX[RWZNGk]oYLW ^L@N  isx{vuxgokkGWRkCGC  VMVVk i\_BFFQX[RWZNGk]oC[Q BXU  isx{vuxgokkGWRkD@WYYENNCMMkki\_BFFQX[RWZNGk]oC[Q BXU  i
O>sx{vuxgoC[Q BXU  i	\_BFFQX[RWZNGk]oU_GSMD@V  i>I>>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGC[Q BXU  [GD[EZLN>>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>>I>>>>>RAZW@][ZQEADMZ@YXBkFZRF@V>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V  HHsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU FQ@AFZ>]R]Z@SQ@k[D@][ZXSDQk^Y[_N[  
sx{vuxgokkGWRkNWYM^SkLZ[BNkiFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  SQ@k@FUZG]QZ@C[Q BXU FQ@AFZ>]RLA]_R\MNS\]PFFQ@AFZ>FP ZRYLGX@BR	M_E@QREC][XSDQk^Y[_N[  >]Rsx{vuxgokkGWRkCGC  VMVVk iFP ZRYLGX@BRHHsx{vuxgokkGWRkD@WYYENNCMMkkiFP ZRYLGX@BRLLPHHXABG]WV@AL\FP ZRYLGX@BRHHM[YQk NNVYMFB\FP ZRYLGX@BRO>FP ZRYLGX@BR	RUXGQ>>>UUEQYFY@N	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iUUEQYFY@NXABG]WV@AL\UUEQYFY@NM[YQk NNVYMFB\UUEQYFY@NO>>>YSWP_GN@FXXNWCUNEM UUEQYFY@NRS^]Q]]ZB@[U >FP ZRYLGX@BR	UUEQYFY@N>I>]RFP ZRYLGX@BRO>tADPU@Qk[D@][ZNWCUNEM sx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Q BXU >FQ@AFZ>>>I>I>]ZS@EXLSY	UFFUMR^N]SFX^UDZ^SGFZ>>BRMUD]WD	VZ[[SF]P]DGWUAZ>LX\^UWWDYQ\R@	[FZWA_XLGNXRBRMUD]WD  >>>]Rsx{vuxgokkGWRkWBSB\_k iLX\^UWWDYQ\R@O>>>R[FQUW\LX\^UWWDYQ\R@UGMFkYLAQVWkNkO>]Rsx{vuxgokkGWRkQDZV_kiMFkYLAQVWkNk			YLW ^L@N  ]ZS@EXLSYoi	BRMUD]WDMFkYLAQVWkNk>>>I>I>]RPQR]ZQPU_GSMD@Vsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>>>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkicdkdxas}zkp}fYLW ^L@N UGM@SVW@G_LB]ZS@EXLSYoi	M@SVW@G_LB>I>>]ZS@EXLSY	sx{vuxgokkGWRk_SM[G_FkLFk i]ZS@EXLSY>[_D@R]DPF	UFFUM>>WRA[@SF\ZPSB	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@N sx{vuxgokkGWRkQDZV_kiFP ZRYLGX@BR >R[FQUW\]ZS@EXLSYUGLUkFX_AZZZFQO>PGA_N 	tsx{vuxgokkGWRkDNNU_UYWXVVkiLUkFX_AZZZFQ>]RPGA_N HHPGA_N 	  W[Z@]ZAQ>>>>DLVNX[A\BX	tsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQRUXGQZAXX  >]Rsx{vuxgokkGWRkCGC  VMVVk iDLVNX[A\BXHHXABG]WV@AL\DLVNX[A\BXW[Z@]ZAQ>>>]RLUkFX_AZZZFQ		R^N]SFX^UDZ^SGFZsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[  DLVNX[A\BX		WRA[@SF\ZPSBW[Z@]ZAQ>[_D@R]DPFoi	LUkFX_AZZZFQ>I>]R[_D@R]DPFO>tADPU@Qk[D@][ZRS^]Q]]ZB@[U sx{vuxgokkGWRkNWYM^SkLZ[BNkiNWCUNEM >>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NGQ@k@FUZG]QZ@NWCUNEM   >FQ@AFZ>I>tADPU@Qk[D@][ZXSDQk^Y[_N[  sx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Q BXU >R[FQUW\[_D@R]DPFUG@WS\XZ[QkO>SUB\XXALLBWR W\F X@WS\XZ[Qk >]R^EQW_ZP\[\_^S^@WS\XZ[QkMV\Yk_]LXPMFP ZRYLGX@BRO>[URLARkUQG\YP@WS\XZ[Qk>CUB_YSQVGGNP[_B@WS\XZ[Qk>SUB\XXALLBWR W\F X@WS\XZ[Qk >RkV [kV DU^_@WS\XZ[Qk>>>>]R@WS\XZ[Qk			R^N]SFX^UDZ^SGFZO>Z@SSV]@AXS]ZZY@FAQ>WU^YMASDXk_GG@FAQ>I>>IQXGQO>SUB\XXALLBWR W\F X@WS\XZ[Qk>I>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGC[Q BXU [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZE]CQLV_MRDNRF>O>G@U@]WRYCD]kCCSNU	RUXGQ>]RRYCD]kCCSNUFQ@AFZ>RYCD]kCCSNU	@FAQ>@FMO>UGLQX @SCLAG>>QEADMZ@YXBkFZRF@V>>>>UF@PLF@XkFD^P>\N^PC_@DLR[FBFQGL>RW_VBDDPP[]EME>>>>_VC@]kZVFR>S_\_RA^UkAL\[^Y>>NAGECUZEWRLU VXW>UWFLLY[ELA]BBSC>]RNCEYDFYSUkFBUFXGUYO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  P]PkUW@][ZNWCUNEM O>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ sx{vuxgokkGWRkA[^M[ DkiU_GSMD@V >IQXGQO>VMR^VBCUFWXDC[Q BXU C[Q BXU >I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>>RAZW@][ZN\]ZDXN kRPM>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V  HHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U FQ@AFZ>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[   HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N FQ@AFZ>[PBCS@XBRQR	sx{vuxgokkGWRkNWYM^SkLZ[BNki>>>>]R[PBCS@XBRQR]Z@tSQ@k[D@][ZYLW ^L@N FQ@AFZ>tADPU@Qk[D@][ZYLW ^L@N [PBCS@XBRQRXSDQk^Y[_N[  >tsx{vuxgokkGWRkVkFMXL ki\[YQkAFXUFFUMC[Q BXU	
NWCUNEM	
RUXGQXSDQk^Y[_N[  	
RUXGQ>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZNCEYDFYSUkFBUFXGUY>>O>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[   O>FQ@AFZ@FAQ>>>>I>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U SQ@k@FUZG]QZ@DPAZGEVRQCQ_O>FQ@AFZRUXGQ>I>>L@RP^R^]Q	XR@SBMF[\@XR>>>>\U^L A[FUBYXY	BNGBN E@XYFNMSBU_GSMD@VRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k i\U^L A[FUBYXY]GGQ@\U^L A[FUBYXYoYLW ^L@N i]Z@\U^L A[FUBYXYoU_GSMD@V i
	]Z@\U^L A[FUBYXYoU_GSMD@V i	L@RP^R^]Q	]Z@\U^L A[FUBYXYoRS^]Q]]ZB@[U i>EYF]EX^PZkZE	]Z@SQ@k[D@][ZYLW ^L@N >]REYF]EX^PZkZE
sx{vuxgokkGWRkNWYM^SkLZ[BNkiEYF]EX^PZkZEL@RP^R^]QO>FQ@AFZRUXGQ>>>I>>>BkLANZCE@	]Z@SQ@k[D@][ZC[Q BXU >]RBkLANZCE@
O>]ELXkGLM XM^	]Z@SQ@k[D@][ZNWCUNEM >^WAAPZMkk	UFFUM    >YA[]^EYQQ	^WAAPZMkkosx{vuxgokkGWRk]LMMNL  Gk isx{vuxgokkGWRkPYBC^AAPLk i]ELXkGLM XM^i>YA[]^EYQQ	sx{vuxgokkGWRkLFUXCD_ k i]Z@YA[]^EYQQ>]Rsx{vuxgokkGWRkNWYM^SkLZ[BNkiBkLANZCE@YA[]^EYQQO>FQ@AFZRUXGQ>I>I>>FQ@AFZ@FAQ>I>>RAZW@][Z]EUXLPEA]ZARkV>O>>>]ELXkGLM XM^	]Z@SQ@k[D@][ZYLW ^L@N >ADPU@Qk[D@][ZXSDQk^Y[_N[  ]ELXkGLM XM^>ADPU@Qk[D@][ZRS^]Q]]ZB@[U sx{vuxgokkGWRkNWYM^SkLZ[BNki>I>>>RAZW@][ZM B] \DWE[Q>O>>>AYP BG^ B	UFFUM>@FMO>AYP BG^ BoC[Q BXU  i	XCDS]V]N]\U[DX C>AYP BG^ BoNWCUNEM i	d|dkbqfg}{z>AYP BG^ BoU_GSMD@V i	sx{vuxgokkGWRkLEG\G\DMQADki>AYP BG^ BoC[Q BXU i	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V ]GkGGX>AYP BG^ BoXSDQk^Y[_N[  i	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V ]GkYAX@]G]@Q>AYP BG^ BoC[Q BXU i	]GGQ@sx{vuxgoU_GSMD@V iG@F]ZSsx{vuxgoYLW ^L@N i>AYP BG^ BoC[Q BXU  i	]GGQ@kgqfbqfoU_GSMD@Visx{vuxgokkGWRkQDZV_kiG@F]ZSkgqfbqfoXSDQk^Y[_N[ i >B@DRVUGMV	]GGQ@sx{vuxgoRS^]Q]]ZB@[U  isx{vuxgokkGWRkCGC  VMVVk isx{vuxgoYLW ^L@N  isx{vuxgokkGWRk\G[ML]GWkisx{vuxgoXSDQk^Y[_N[   i>AYP BG^ BoC[Q BXU i	B@DRVUGMV		>>>AYP BG^ BoC[Q BXU i	sx{vuxgokkGWRkD@WYYENNCMMkkiB@DRVUGMV>AYP BG^ BoRS^]Q]]ZB@[U i	QYD@Msx{vuxgoXSDQk^Y[_N[  i>>>>AYP BG^ BoRS^]Q]]ZB@[U i	QYD@Msx{vuxgoYLW ^L@N i>AYP BG^ BoYLW ^L@N i	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU ]Z@tSQ@k[D@][ZXSDQk^Y[_N[  >AYP BG^ BoRS^]Q]]ZB@[U  i	kP^D_FS\YY WXSDQk^Y[_N[   		>AYP BG^ BoYLW ^L@N i	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U ]Z@tSQ@k[D@][ZNWCUNEM >>AYP BG^ BoYLW ^L@N i	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V ]Z@tSQ@k[D@][ZC[Q BXU >AYP BG^ BoC[Q BXU i	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU]Z@tSQ@k[D@][ZYLW ^L@N>M YGAF^PE@ZQB	AEZGREWF[>AYP BG^ BoYLW ^L@Ni	tsx{vuxgokkGWRk@Y@R NPPDCC@kiM YGAF^PE@ZQBU_GSMD@VBDNA^B[\^GC@BZtsx{vuxgokkGWRkBYEVDGkUNk iM YGAF^PE@ZQBXSDQk^Y[_N[ RUXGQZAXX>AYP BG^ BoNWCUNEM i	tsx{vuxgokkGWRk@Y@R NPPDCC@kiM YGAF^PE@ZQBU_GSMD@VBDNA^B[\^GC@BZtsx{vuxgokkGWRkBYEVDGkUNk iM YGAF^PE@ZQBC[Q BXURUXGQZAXX >AYP BG^ BoNWCUNEMi	tsx{vuxgokkGWRk@Y@R NPPDCC@kiM YGAF^PE@ZQBYLW ^L@NBDNA^B[\^GC@BZtsx{vuxgokkGWRkBYEVDGkUNk iM YGAF^PE@ZQBRS^]Q]]ZB@[URUXGQZAXX  >WCFRRG EGLRM	RS^]Q]]ZB@[USL@D ]FAVZuvgdu`|S>DUE^CRU\M	RS^]Q]]ZB@[USL@D ]FAVZuvgdu`|S>AYP BG^ BoXSDQk^Y[_N[ i	>R[FQUW\UFFUMGM_EAV^VFWM YGAF^PE@ZQBuvgdu`|XSDQk^Y[_N[ UG@WA]MBX_O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WA]MBX_WCFRRG EGLRMXSDQk^Y[_N[  AYP BG^ BoC[Q BXUi	>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WA]MBX_DUE^CRU\M]Z@tsx{vuxgokkGWRkUMX_NCYCki@WA]MBX_DUE^CRU\M
sx{vuxgokkGWRkNWYM^SkLZ[BNki O>AYP BG^ BoYLW ^L@Ni	>VFQU_>I>I>>>>AZGQ@DUE^CRU\M@WA]MBX_>>>[YFDADR]LW	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Ntsx{vuxgokkGWRkQZNVM]LkiNWCUNEMRUXGQ>>]Rsx{vuxgokkGWRkCGC  VMVVk i[YFDADR]LWHH[YFDADR]LW			HH[YFDADR]LW			RS^]Q]]ZB@[U[YFDADR]LW	XSDQk^Y[_N[ >AYP BG^ BoRS^]Q]]ZB@[Ui	tsx{vuxgokkGWRk@Y@R NPPDCC@kiuvgdu`|[YFDADR]LWsx{vuxgokkGWRkUAU[DUV]kWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iuvgdu`|[YFDADR]LWNWCUNEM		RUXGQ>>>AYP BG^ BoRS^]Q]]ZB@[Ui	tsx{vuxgokkGWRk@Y@R NPPDCC@kiuvgdu`|C[Q BXUsx{vuxgokkGWRkUAU[DUV]kWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iuvgdu`|C[Q BXUU_GSMD@V		RUXGQ>AYP BG^ BoRS^]Q]]ZB@[U i	tsx{vuxgokkGWRk@Y@R NPPDCC@kiuvgdu`|RS^]Q]]ZB@[Usx{vuxgokkGWRkUAU[DUV]kWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iuvgdu`|NWCUNEMRUXGQZAXXC[Q BXU		RUXGQ>AYP BG^ BoXSDQk^Y[_N[ i	PQR]ZQPNWCUNEM>AYP BG^ BoC[Q BXUi	PQR]ZQPU_GSMD@VHHPQR]ZQPXSDQk^Y[_N[ HHPQR]ZQPRS^]Q]]ZB@[UHHsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUHHsx{vuxgokkGWRkQk[VUA]AQRk iRS^]Q]]ZB@[UHH]GGQ@sx{vuxgoU_GSMD@ViHHsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU>AYP BG^ BoU_GSMD@Vi	]Z@SQ@k[D@][ZXSDQk^Y[_N[  >AYP BG^ BoXSDQk^Y[_N[ i	]Z@SQ@k[D@][ZNWCUNEM >AYP BG^ BoU_GSMD@V i	]Z@SQ@k[D@][ZYLW ^L@N >>>>MkQRSWYPRX	M_E@QREC][YLW ^L@N UFFUM>RCU\k@QNE	>PE]]U@LF[L^[[Q	>]Rsx{vuxgokkGWRkWBSB\_k iMkQRSWYPRXO>R[FQUW\MkQRSWYPRXUGMFkYLAQVWkNkO>]RVU@L@ZQR]QCMFkYLAQVWkNk			W[Z@]ZAQ>RCU\k@QNE>>>>[BZVC\FDGF	sx{vuxgokkGWRkWBSB\_k iMFkYLAQVWkNk]Z@]GGQ@MFkYLAQVWkNkoNWCUNEM iMFkYLAQVWkNkoRS^]Q]]ZB@[U i>GLL][\B[\	sx{vuxgokkGWRkWBSB\_k iMFkYLAQVWkNk]GGQ@MFkYLAQVWkNkoXSDQk^Y[_N[  i]Z@MFkYLAQVWkNkoC[Q BXU i>]R[BZVC\FDGFGLL][\B[\HHGLL][\B[\sx{vuxgokkGWRkNWYM^SkLZ[BNkiPE]]U@LF[L^[[Q>I>I>AYP BG^ BoC[Q BXU  i	RCU\k@QNE>AYP BG^ BoRS^]Q]]ZB@[U i	PE]]U@LF[L^[[Q>[]P]VSDV@W]VY	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tSQ@k[D@][ZRS^]Q]]ZB@[U >AYP BG^ BoNWCUNEM i	sx{vuxgokkGWRkCGC  VMVVk i[]P]VSDV@W]VYsx{vuxgokkGWRkQDZV_ki[]P]VSDV@W]VYL L>>BD_BM\ SNNREV	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM tSQ@k[D@][ZC[Q BXU UFFUMUFFUM>>AYP BG^ BoC[Q BXUi	sx{vuxgokkGWRkWBSB\_k iBD_BM\ SNNREVQYD@MBD_BM\ SNNREVo@iHHQYD@MBD_BM\ SNNREVoXSDQk^Y[_N[ i>IWU@W\`\F[CUVXQ[GD[EZLNO>AYP BG^ BoYLW ^L@Ni	sx{vuxgokkGWRkQDZV_ki[GD[EZLN
SQ@yQGGUSQ>IWU@W\qLWQD@][Z[GD[EZLNO>AYP BG^ BoC[Q BXUi	sx{vuxgokkGWRkQDZV_ki[GD[EZLN
SQ@yQGGUSQ>I>FQ@AFZAYP BG^ B>I>>>>>>RAZW@][ZBN^\YNBk_ANDC\RR>O>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>FQ@AFZG@F]ZSG]@QkAFXC[Q BXU>>>>I>FQ@AFZsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM G@F]ZSCDkX[S]ZkAFX>I>>RAZW@][Z]]Ak[ZG\^^RAP]UMAR^WQEERF\VVZXC>>>>O>BGSY[k	>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>>>BGSY[k	G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXW[ZG@UZ@YLW ^L@N>I>]RBGSY[ksx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>BGSY[k	G@F]ZSsx{vuxgokkGWRkk@\\]WGVkiSQ@kG]@QkAFXW[ZG@UZ@XSDQk^Y[_N[ >I>>]RBGSY[ksx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>BGSY[k	G@F]ZSsx{vuxgokkGWRkk@\\]WGVkiSQ@kVX[S]ZR[XSDQk^Y[_N[ W[ZG@UZ@XSDQk^Y[_N[ >I>]RBGSY[ksx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>BGSY[k	G@F]ZSsx{vuxgokkGWRkk@\\]WGVkiG@F]ZSSQ@k[D@][ZNWCUNEMW[ZG@UZ@YLW ^L@N>>>>I>]RBGSY[k]GGQ@kgqfbqfoU_GSMD@ViO>BGSY[k	G@F]ZSkgqfbqfoNWCUNEMi>>>I>]RBGSY[k]GGQ@kgqfbqfoRS^]Q]]ZB@[U iO>BGSY[k	G@F]ZSkgqfbqfoYLW ^L@N i>I>>>]RBGSY[kO>FQ@AFZR^WQEERF\VVZXC>I>FQ@AFZBGSY[k>I>RAZW@][ZZBN[WFDF\\GW^LMYLVk	>O>@FMO>>>SDC\PVUZFPF\N	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU]Z@tsx{vuxgokkGWRkQZNVM]LkiRS^]Q]]ZB@[U>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V tsx{vuxgokkGWRkR_GC[[k\k iLUVL>CXQRFZ\PG@[	SDC\PVUZFPF\N
LWLSDC\PVUZFPF\N SDC\PVUZFPF\NSDC\PVUZFPF\N
SDC\PVUZFPF\N	 j>]R\GW^LMYLVk
CXQRFZ\PG@[
\GW^LMYLVkCXQRFZ\PG@[	\GW^LMYLVk>sx{vuxgoXSDQk^Y[_N[ i	sx{vuxgokkGWRkPX^@X\kki@FAQCXQRFZ\PG@[>>>>]RNCEYDFYSUkFBUFXGUYO>FQ@AFZ>>>>I>]RPZEURB[UWFUPNWCUNEMO>FQ@AFZ>>I>>S]UDGSQE^M	sx{vuxgokkGWRkPX^@X\kki@FAQ>R_LDU^ [FNB	\^@L\ EG_\]Z@CXQRFZ\PG@[>]R>>>sx{vuxgokkGWRkWBSB\_k iR_LDU^ [FNB>HH]GGQ@R_LDU^ [FNBoXSDQk^Y[_N[ iHHsx{vuxgokkGWRkCGC  VMVVk iR_LDU^ [FNBoNWCUNEMiHHR_LDU^ [FNBoNWCUNEMi>>HH]GGQ@R_LDU^ [FNBoNWCUNEM iHHsx{vuxgokkGWRkWBSB\_k iR_LDU^ [FNBoYLW ^L@N iHHQYD@MR_LDU^ [FNBoYLW ^L@N i>>>O>]EUXLPEA]ZARkV>FQ@AFZ>I>V_[NDGkSGAPPV	R_LDU^ [FNBoXSDQk^Y[_N[ i>>[FGB[PRRY]	R_LDU^ [FNBoRS^]Q]]ZB@[Ui>>>>YSWP_GN@FXXRS^]Q]]ZB@[UV_[NDGkSGAPPVYLW ^L@N >YSWP_GN@FXXC[Q BXUsx{vuxgokkGWRkUAU[DUV]kWkiV_[NDGkSGAPPVU_GSMD@V			U_GSMD@V >FCUW@_FQQ]UB	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMG@F]ZSSQ@k[D@][ZU_GSMD@V >]RFCUW@_FQQ]UB		sx{vuxgokkGWRkUFBG[ZLZN Gk iFCUW@_FQQ]UB[FGB[PRRY]@FAQO>>>>[FGB[PRRY]	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRkk\SZ\YY ki[FGB[PRRY]UFFUMFCUW@_FQQ]UB>sx{vuxgokkGWRkPMEQ[PPki[FGB[PRRY]>sx{vuxgokkGWRkF[MVXEDMMXR]ki[FGB[PRRY]FCUW@_FQQ]UB>IQXGQ]Rsx{vuxgokkGWRkEMVLY\Aki[FGB[PRRY]
O>sx{vuxgokkGWRkPMEQ[PPki[FGB[PRRY]>I>>>]Rsx{vuxgokkGWRkPX^@X\kki@FAQS]UDGSQE^M
]Z@CXQRFZ\PG@[O>]EUXLPEA]ZARkV>FQ@AFZ>I>>>ZXN_@A_ GEQ	^kRNV^ZkB]X\>]R@WRYSCWMRD]^PLZXN_@A_ GEQO>ZXN_@A_ GEQ	^kRNV^ZkB]X\>I>>_M]AUPN]SDE	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>R[FQUW\UFFUMSQ@k[D@][ZYLW ^L@N UFFUMUGLUkFX_AZZZFQO>]Rsx{vuxgokkGWRkCGC  VMVVk iLUkFX_AZZZFQLUkFX_AZZZFQO>>>>_M]AUPN]SDEoi	LUkFX_AZZZFQ>I>I>I>>\LQ[XPNP\	UFFUM>]RPQR]ZQPYLW ^L@NO>QZVC[WLRPG	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM tsx{vuxgokkGWRkV^E_YEEGLMVkisx{vuxgokkGWRkDMF\VYFZMkicdyakdxas}zkp}fYLW ^L@NRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iQZVC[WLRPGO>R[FQUW\QZVC[WLRPGUG@WS\XZ[QkO>\LQ[XPNP\oi	sx{vuxgokkGWRkQANE SG_kXV\ki@WS\XZ[Qk>>>I>I>>>I>>>>>_GMPRk[LAGN]WR\	UFFUM>NWCUNEM	
]]Ak[ZG\^^RAP]UMA>C[Q BXU	
XCDS]V]N]\U[DX C>>NWCUNEM	
sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N >>U_GSMD@V	
sx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|NWCUNEM>C[Q BXU	
_M]AUPN]SDE>XSDQk^Y[_N[ 	
\LQ[XPNP\>C[Q BXU 	
BN^\YNBk_ANDC\RR>RS^]Q]]ZB@[U	
[V^QW@SWRL^AS_XFMZXN_@A_ GEQ>C[Q BXU	
[V^QW@R]BB@CWC XMZXN_@A_ GEQ>U_GSMD@V	
LG]@_AQYUSX	VX[^CB]BANBDSFBQXN>>>BZ \SLUD	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ CDk^G[ZkQZW[PQ_GMPRk[LAGN]WR\sx{vuxgokkGWRkPDZXFZEVS\Ski_GMPRk[LAGN]WR\>>>QEBF^\G@R	RPSR]FXSNC^E@BZ \SLUDV_[NDGkSGAPPV>UEFXYZRMVW\PG	UFFUMU_GSMD@V	
U_GSMD@V>AMQACkQBCNU^	ZAXX>LDU QGFFQ	RUXGQ>>>]EUXLPEA]ZARkV>sx{vuxgoXSDQk^Y[_N[ i	RUXGQ>>>>R[FQUW\[FGB[PRRY]UG@LDZEPEW[[O>>[[FRPWYBAG@	CXQRFZ\PG@[sx{vuxgokkGWRkPX^@X\kki@FAQS]UDGSQE^M>]R[[FRPWYBAG@O>VFQU_>I>P\EZ R\GU	sx{vuxgokkGWRkPYBC^AAPLk ij ]Z@[[FRPWYBAG@>>@LDZEPEW[[	sx{vuxgokkGWRk\G[ML]GWkiG@F]ZS@LDZEPEW[[>>>]R@LDZEPEW[[O>W[Z@]ZAQ>I>>@FMO>>>>Vk[MMXGS	V_[NDGkSGAPPV>>>>^FX@FL[Mk_Q^	WZLSB]YNVRG^VXPF]PA@LDZEPEW[[QEBF^\G@RUEFXYZRMVW\PGP\EZ R\GURAZW@][ZXG_QLkAW@D\UBAAGQVk[MMXGSO>]R^RSDR NMZ]@Dsx{vuxgokkGWRkD@WYYENNCMMkkiXG_QLkAW@D\UBAO>sx{vuxgoXSDQk^Y[_N[ i	@FAQ>FQ@AFZRUXGQ>I>AYP BG^ B	RPSR]FXSNC^E@XG_QLkAW@D\UBAVk[MMXGS>]RAYP BG^ BFQ@AFZRUXGQ>FQ@AFZsx{vuxgokkGWRkWBSB\_k itsx{vuxgokkGWRkWL[M\VYkisx{vuxgokkGWRk\G[ML]GWkiAYP BG^ B@FAQ>I>]R^FX@FL[Mk_Q^O>]RQYD@Msx{vuxgoU_GSMD@ViO>[]\CNNBEZB[Q\APGU_GSMD@V U_GSMD@V >>>>VFQU_>>>I>[]\CNNBEZB[Q\APGC[Q BXUU_GSMD@V@LDZEPEW[[>W[Z@]ZAQ>I>>CAAAQ_	RPSR]FXSNC^E@^FX@FL[Mk_Q^V_[NDGkSGAPPV>]RCAAAQ_O>>[]\CNNBEZB[Q\APGYLW ^L@NC[Q BXU@LDZEPEW[[>W[Z@]ZAQ>I>AMQACkQBCNU^	sx{vuxgokkGWRkD@WYYENNCMMkkiCAAAQ_
  ^RSDR NMZ]@Dsx{vuxgokkGWRkD@WYYENNCMMkkiCAAAQ_ZAXXtsx{vuxgokkGWRkWL[M\VYkisx{vuxgokkGWRk\G[ML]GWkiCAAAQ_@FAQ>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^O>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V O>ADPU@Qk[D@][ZC[Q BXU @LDZEPEW[[>I>LDU QGFFQ	@FAQ>VFQU_>>>IQXGQO>[]\CNNBEZB[Q\APGU_GSMD@VC[Q BXU@LDZEPEW[[>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>W[Z@]ZAQ>>IWU@W\qLWQD@][Z[GD[EZLNO>W[Z@]ZAQ>>>>I>I>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^QYD@Msx{vuxgoU_GSMD@ViO>X[@YCRM	RPSR]FXSNC^E@sx{vuxgokkGWRkPDZXFZEVS\SkiUFFUM>RS^]Q]]ZB@[U	
]]Ak[ZG\^^RAP]UMA>YLW ^L@N	
XCDS]V]N]\U[DX C>U_GSMD@V	
sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZU_GSMD@V >>>>NWCUNEM	
>V_[NDGkSGAPPV>>>BZ^GEBSkk\D^	sx{vuxgokkGWRkDMF\VYFZMkiG@F@Fsx{vuxgokkGWRkV\W][LkiX[@YCRMRS^]Q]]ZB@[UXSDQk^Y[_N[  	>R^kQ \ZS^]_	sx{vuxgokkGWRk]^]^MQGkiBZ^GEBSkk\D^>R[FQUW\[FGB[PRRY]UG@LDZEPEW[[O>>>]Rsx{vuxgokkGWRkPX^@X\kki@FAQS]UDGSQE^M
CXQRFZ\PG@[O>VFQU_>I>>>>@LDZEPEW[[	sx{vuxgokkGWRk\G[ML]GWkiG@F]ZS@LDZEPEW[[>]R@LDZEPEW[[			O>W[Z@]ZAQ>>I>Y]^A MD]_M_SS	SL@D ]FAVZ]]Ak[ZG\^^RAP]UMAsx{vuxgokkGWRkPX^@X\kki@FAQj>ZFR GB^_Z	sx{vuxgokkGWRkEMVLY\AkiR^kQ \ZS^]_>>>N]DBV@\CVQ	sx{vuxgokkGWRkUAU[DUV]kWki@LDZEPEW[[			RUXGQ>>>R[FF^P_ NFVB	F^P_ NFVBZFR GB^_ZF^P_ NFVBO>>>]Rsx{vuxgokkGWRkPX^@X\kki@FAQS]UDGSQE^M
CXQRFZ\PG@[O>VFQU_>I>SGVFEFV	F^P_ NFVB			ZFR GB^_Z>EWYDUVQSG	@LDZEPEW[[N]DBV@\CVQYLW ^L@NY]^A MD]_M_SSRS^]Q]]ZB@[UF^P_ NFVBU_GSMD@VZFR GB^_ZRS^]Q]]ZB@[UR^kQ \ZS^]_oF^P_ NFVBi>WNVCUANV GP	MLRQBGXLLQXSSEWYDUVQSGSGVFEFVRAZW@][ZXG_QLkAW@D\UBAAGQV_[NDGkSGAPPVO>AYP BG^ B	RPSR]FXSNC^E@XG_QLkAW@D\UBAV_[NDGkSGAPPV>]RAYP BG^ BFQ@AFZRUXGQ>FQ@AFZsx{vuxgokkGWRkWBSB\_k itsx{vuxgokkGWRkWL[M\VYkisx{vuxgokkGWRk\G[ML]GWkiAYP BG^ B@FAQ>>>>IZAXX>>>>]RSGVFEFVsx{vuxgokkGWRkCGC  VMVVk iWNVCUANV GPWNVCUANV GP		O>>>>kSP	RPSR]FXSNC^E@WNVCUANV GPV_[NDGkSGAPPV>WCFRRG EGLRM	kSPsx{vuxgokkGWRkD@WYYENNCMMkkikSP	  HH^RSDR NMZ]@Dsx{vuxgokkGWRkD@WYYENNCMMkkikSPtsx{vuxgokkGWRkWL[M\VYkisx{vuxgokkGWRk\G[ML]GWkikSP@FAQZAXX>]Rsx{vuxgokkGWRkWBSB\_k iWCFRRG EGLRMO>AMQACkQBCNU^	WCFRRG EGLRM>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>ADPU@Qk[D@][ZXSDQk^Y[_N[ @LDZEPEW[[>I>VFQU_>I>>>>I>>>I>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^O>VFQU_>I>I>>>>I>sx{vuxgoYLW ^L@Ni	RUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^O>FQ@AFZ>I>]RLDU QGFFQO>GXZLM@GDP>I>]RLG]@_AQYUSXsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>PQXQ@Qk[D@][ZFLQWZ ED P C[Q BXU>>AZGQ@sx{vuxgoXSDQk^Y[_N[ ioFLQWZ ED P NWCUNEMi>I>]R]GGQ@sx{vuxgoNWCUNEMiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoXSDQk^Y[_N[  isx{vuxgoYLW ^L@N i	UFFUM>sx{vuxgoYLW ^L@N i	sx{vuxgokkGWRkSENUGEEAMZk isx{vuxgokkGWRkk\SZ\YY kisx{vuxgoC[Q BXUiLG]@_AQYUSX>]R]GGQ@AMQACkQBCNU^oU_GSMD@Visx{vuxgokkGWRkCGC  VMVVk iAMQACkQBCNU^oYLW ^L@NiO>AZGQ@sx{vuxgoU_GSMD@Vi>>SPFEDG[[DXAMQACkQBCNU^oXSDQk^Y[_N[ i]GGQ@AMQACkQBCNU^oRS^]Q]]ZB@[Uisx{vuxgokkGWRkCGC  VMVVk iAMQACkQBCNU^oU_GSMD@ViAMQACkQBCNU^oU_GSMD@ViQYD@MAMQACkQBCNU^oXSDQk^Y[_N[ i>I>>\ MGF\Gk	RUXGQ>LFVW]M_@GQA	UFFUM>>]R]GGQ@AMQACkQBCNU^oYLW ^L@N isx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^oXSDQk^Y[_N[  iO>>>>GFCCMEMBEZ_	UFFUM>>>>>R[FQUW\AMQACkQBCNU^oXSDQk^Y[_N[  iUG]MC[kQAAGCO>]Rsx{vuxgokkGWRkCGC  VMVVk i]MC[kQAAGC]MC[kQAAGC		O>GFCCMEMBEZ_oi	]MC[kQAAGC>I>I>C^GYS\SB	sx{vuxgoRS^]Q]]ZB@[U i>>>GFCCMEMBEZ_	\F^A^\ YFUAMALM]]GFCCMEMBEZ_>sx{vuxgoC[Q BXUi	GFCCMEMBEZ_>LFVW]M_@GQAoC[Q BXU i	GFCCMEMBEZ_>]RQYD@Msx{vuxgokkGWRkk\SZ\YY kiGFCCMEMBEZ_C^GYS\SBHHQYD@Msx{vuxgokkGWRkk\SZ\YY kiC^GYS\SBGFCCMEMBEZ_O>>>\ MGF\Gk	@FAQ>I>I>>]R]GGQ@AMQACkQBCNU^oNWCUNEM  isx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^oXSDQk^Y[_N[   iO>GFCCMEMBEZ_	UFFUM>>R[FQUW\AMQACkQBCNU^oNWCUNEMiUG]MC[kQAAGCO>]Rsx{vuxgokkGWRkCGC  VMVVk i]MC[kQAAGC]MC[kQAAGC		O>>>>GFCCMEMBEZ_oi	]MC[kQAAGC>I>I>C^GYS\SB	sx{vuxgoYLW ^L@N i>GFCCMEMBEZ_	\F^A^\ YFUAMALM]]GFCCMEMBEZ_>sx{vuxgoYLW ^L@N i	GFCCMEMBEZ_>LFVW]M_@GQAoC[Q BXUi	GFCCMEMBEZ_>]RQYD@Msx{vuxgokkGWRkk\SZ\YY kiGFCCMEMBEZ_C^GYS\SBHHQYD@Msx{vuxgokkGWRkk\SZ\YY kiC^GYS\SBGFCCMEMBEZ_O>>>>\ MGF\Gk	@FAQ>>>I>I>>>>]R]GGQ@AMQACkQBCNU^oC[Q BXUisx{vuxgokkGWRkCGC  VMVVk iAMQACkQBCNU^oYLW ^L@NiO>XQYLL XBS\	kP^D_FS\YY WU_GSMD@V>]RXQYLL XBS\		]Z@M_E@QREC][RS^]Q]]ZB@[U 			O>YSWP_GN@FXXC[Q BXUYLW ^L@N>]R]Z@M_E@QREC][C[Q BXU		YSWP_GN@FXXNWCUNEMXSDQk^Y[_N[ >>>>I>>>sx{vuxgoNWCUNEM  i	AMQACkQBCNU^oC[Q BXUi>>>LFVW]M_@GQAoU_GSMD@Vi	AMQACkQBCNU^oRS^]Q]]ZB@[Ui>]Rsx{vuxgokkGWRkk[AFM@ZWUECkiAMQACkQBCNU^oXSDQk^Y[_N[ i		sx{vuxgokkGWRkk[AFM@ZWUECkiXQYLL XBS\HH]Z@M_E@QREC][NWCUNEM			O>]RYSWP_GN@FXXU_GSMD@VAMQACkQBCNU^oRS^]Q]]ZB@[UiRS^]Q]]ZB@[UHHkP^D_FS\YY WC[Q BXU			AMQACkQBCNU^oYLW ^L@NiO>YSWP_GN@FXXRS^]Q]]ZB@[UXSDQk^Y[_N[ >@FMO>]R@WUEVQEG\SMLR ]MRYSWP_GN@FXXXSDQk^Y[_N[ NWCUNEM>IWU@W\`\F[CUVXQ[GD[EZLNO>>IWU@W\qLWQD@][Z[GD[EZLNO>I>IQXGQO>]EUXLPEA]ZARkV>FQ@AFZ>I>I>AZGQ@XQYLL XBS\>>I>\]@DXW^Y	]GGQ@AMQACkQBCNU^oC[Q BXU  isx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^oYLW ^L@N  iAMQACkQBCNU^oXSDQk^Y[_N[ iUFFUM>]R]GGQ@\]@DXW^YoXSDQk^Y[_N[  isx{vuxgokkGWRkCGC  VMVVk i\]@DXW^YoU_GSMD@ViO>]Rsx{vuxgokkGWRkD@WYYENNCMMkki\]@DXW^YoYLW ^L@Ni
 O>sx{vuxgoU_GSMD@V   i	\]@DXW^YoNWCUNEMi>LFVW]M_@GQAoU_GSMD@Vi	\]@DXW^YoYLW ^L@Ni>IQXGQO>sx{vuxgoYLW ^L@N   i	>LFVW]M_@GQAoXSDQk^Y[_N[ i	>YSWP_GN@FXXC[Q BXUNWCUNEM>I>I>]R]GGQ@\]@DXW^YoNWCUNEMisx{vuxgokkGWRkCGC  VMVVk i\]@DXW^YoXSDQk^Y[_N[ iO>]Rsx{vuxgokkGWRkD@WYYENNCMMkki\]@DXW^YoC[Q BXUi
O>sx{vuxgoRS^]Q]]ZB@[U  i	\]@DXW^YoC[Q BXU i>>>LFVW]M_@GQAoNWCUNEM i	\]@DXW^YoNWCUNEM i>IQXGQO>sx{vuxgoC[Q BXU  i	>LFVW]M_@GQAoU_GSMD@V i	>YSWP_GN@FXXXSDQk^Y[_N[  C[Q BXU>>I>I>>B] XUWSXLGCM	]GGQ@AMQACkQBCNU^oRS^]Q]]ZB@[U isx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^oRS^]Q]]ZB@[U iAMQACkQBCNU^oRS^]Q]]ZB@[U iUFFUM>MX^CLXS	UFFUM>RS^]Q]]ZB@[U  	
YLW ^L@N  >C[Q BXU 	
RS^]Q]]ZB@[U >>>>XSDQk^Y[_N[  	
XSDQk^Y[_N[  >YLW ^L@N 	
C[Q BXU>>>RS^]Q]]ZB@[U	
U_GSMD@V>NWCUNEM	
C[Q BXU >>R[FQUW\MX^CLXSUG]QE^ZFE[WVUBS@S	
PZNS^]YkO>]R]GGQ@B] XUWSXLGCMo]QE^ZFE[WVUBS@Sisx{vuxgokkGWRkCGC  VMVVk iB] XUWSXLGCMo]QE^ZFE[WVUBS@Sisx{vuxgokkGWRkD@WYYENNCMMkkiB] XUWSXLGCMo]QE^ZFE[WVUBS@Si
O>LFVW]M_@GQAoPZNS^]Yki	B] XUWSXLGCMo]QE^ZFE[WVUBS@Si>I>>I>]R]GGQ@AMQACkQBCNU^oRS^]Q]]ZB@[U isx{vuxgokkGWRkUVRFFFZkiAMQACkQBCNU^oYLW ^L@N iO>C[Fk]VC\YS	]Z@AMQACkQBCNU^oC[Q BXU i>]RC[Fk]VC\YS
	C[Fk]VC\YS	LFVW]M_@GQAoXSDQk^Y[_N[  i	C[Fk]VC\YS>I>]R]GGQ@AMQACkQBCNU^oYLW ^L@N isx{vuxgokkGWRkUVRFFFZkiAMQACkQBCNU^oYLW ^L@NiO>>kW]	]Z@AMQACkQBCNU^oC[Q BXUi>]RkW]
	kW]	   LFVW]M_@GQAoC[Q BXUi	kW]>I>]RQYD@MLFVW]M_@GQAO>PQXQ@Qk[D@][ZNWCUNEM >PQXQ@Qk[D@][ZU_GSMD@V>ADPU@Qk[D@][ZU_GSMD@V sx{vuxgokkGWRkNWYM^SkLZ[BNki>>PQXQ@Qk@FUZG]QZ@YLW ^L@N>_VC@]kZVFR>NAGECUZEWRLU VXW>FQ@AFZ>I>>>YDA@GLWN ]	BNGBN E@XYFNMSBYLW ^L@NRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iYDA@GLWN ]O>LFVW]M_@GQA	sx{vuxgokkGWRkPE\P] W]XPFFAkiYDA@GLWN ]LFVW]M_@GQA>>>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>>>L@RP^R^]Q	XR@SBMF[\@XR>]R]GGQ@LFVW]M_@GQAoNWCUNEMi]Z@LFVW]M_@GQAoYLW ^L@Ni
	 ]Z@LFVW]M_@GQAoNWCUNEMi	LLRRQL@RP^R^]Q	]Z@LFVW]M_@GQAoNWCUNEMi>GQ@k@FUZG]QZ@DPAZGEVRQCQ_LFVW]M_@GQAL@RP^R^]Q>I>>>>>>>>]RDUCXUFUD^kQXRS^]Q]]ZB@[ULFVW]M_@GQAU_GSMD@VO>\V]Z^\R^URFR	BNGBN E@XYFNMSBXSDQk^Y[_N[ ZAXX>]Rsx{vuxgokkGWRkWBSB\_k i\V]Z^\R^URFRHH\V]Z^\R^URFR	LFVW]M_@GQAO>>>>]EUXLPEA]ZARkV>FQ@AFZ>I>AZGQ@\V]Z^\R^URFR>I>]R]GGQ@LFVW]M_@GQAoNWCUNEMisx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>UWW\\ LB[	CDkSQ@kGW\QPAXQPkQBQZ@Y]BFFRNL@_MGA^>]RUWW\\ LB[]Z@UWW\\ LB[
]Z@QFBUX		]Z@LFVW]M_@GQAoXSDQk^Y[_N[ iO>CDkWXQUFkGW\QPAXQPk\[[_Y]BFFRNL@_MGA^>CDkGW\QPAXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNkisx{vuxgokkGWRkLFUXCD_ k iXSDQk^Y[_N[ Y]BFFRNL@_MGA^>>I>I>ADPU@Qk[D@][ZU_GSMD@Vsx{vuxgokkGWRkNWYM^SkLZ[BNki>PQXQ@Qk[D@][ZNWCUNEM >PQXQ@Qk[D@][ZC[Q BXU>PQXQ@Qk@FUZG]QZ@U_GSMD@V>_VC@]kZVFR>NAGECUZEWRLU VXW>>>]R\ MGF\GkO>P][M_RWPV]SU]F>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>IR]ZUXXMO>AZGQ@sx{vuxgoYLW ^L@Ni>L^U[US^\kM^YLW ^L@N>I>>I>>RAZW@][ZSPFEDG[[DXSk@@ZGSCR \QMUkG[	AY_L_AMDFPN 	RUXGQ>O>]RPZEURB[UWFUPRS^]Q]]ZB@[UFQ@AFZ>>@FMO>WPE^^L^V[^AA	Q@E@_U]k]]E@PAQY>>>>]RWPE^^L^V[^AA
sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ ^RSDR NMZ]@Dsx{vuxgokkGWRkD@WYYENNCMMkkiSk@@ZGSCO>>>>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ RS^]Q]]ZB@[U>FQ@AFZ>I>>AZGQ@WPE^^L^V[^AA>>ZU P_ZV]G	tsx{vuxgokkGWRkWBDQ[VVAZE\kiSk@@ZGSC@FAQ>]Rsx{vuxgokkGWRkCGC  VMVVk iZU P_ZV]Gsx{vuxgokkGWRkD@WYYENNCMMkkiZU P_ZV]G
  ZU P_ZV]G	^UNF\NZMLZLZkN[XAZU P_ZV]G>]RZU P_ZV]GHHsx{vuxgokkGWRkD@WYYENNCMMkkiZU P_ZV]GLPLHHsx{vuxgokkGWRkUAU[DUV]kWkiZU P_ZV]GYLW ^L@N		O>FQ@AFZ>>>>I>]RM[YQk NNVYMFB\ZU P_ZV]GO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UXSDQk^Y[_N[  >>>FQ@AFZ>>>I>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ sx{vuxgokkGWRkQDZV_kiZU P_ZV]G YQDMFCEUO>]RR \QMUkG[		R \QMUkG[		YQDMFCEUoiO>>>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UC[Q BXU>FQ@AFZ>I>R \QMUkG[	YQDMFCEUoi>IQXGQO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ C[Q BXU>>FQ@AFZ>I>]RAY_L_AMDFPN BQFG][ZkW[YDUFQR \QMUkG[XCDS]V]N]\U[DX C	O>FQ@AFZ>>>I>NVZYSNB	Z@SSV]@AXS]ZZY>]RNVZYSNBHHsx{vuxgokkGWRkD@WYYENNCMMkkiNVZYSNB O>>>>[]\CNNBEZB[Q\APGYLW ^L@NC[Q BXU>FQ@AFZ>I>EL]ZkEGE	SQ@k[D@][ZRS^]Q]]ZB@[U>>]Rsx{vuxgokkGWRkCGC  VMVVk iEL]ZkEGEsx{vuxgokkGWRkUAU[DUV]kWkiEL]ZkEGEsx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]GH			O>FQ@AFZ>>>>I>UNDQQFEX	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[  sx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]G>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiUNDQQFEXO>>>FQ@AFZ>I>AZGQ@UNDQQFEX>]RAY_L_AMDFPN O>\UYPGRMVCA	tSQ@k[D@][ZC[Q BXU>]Rsx{vuxgokkGWRkCGC  VMVVk i\UYPGRMVCAsx{vuxgokkGWRkUAU[DUV]kWki\UYPGRMVCAsx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]GH			O>>>]_LPLFYR	]Z@sx{vuxgokkGWRkQDZV_ki\UYPGRMVCAsx{vuxgokkGWRkUAU[DUV]kWki\UYPGRMVCAH>]R]_LPLFYRsx{vuxgokkGWRkNWYM^SkLZ[BNki]_LPLFYR FQ@AFZ>I>AZGQ@\UYPGRMVCA]_LPLFYR>I>DRLSL^XYMU	RUXGQ>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[   sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>LX]Y\PSXF@Sk\	sx{vuxgokkGWRkVkFMXL ki\[YQkAFXUFFUMXSDQk^Y[_N[ 	
XSDQk^Y[_N[ 	
C[Q BXU	
RUXGQC[Q BXU	
  >]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ ]GkCDkQFF[FLX]Y\PSXF@Sk\O>DRLSL^XYMU	]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQLX]Y\PSXF@Sk\
	 >I>I>MY]RDSVNZMSQSW	RUXGQ>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>^@RNW_]kVSNAU	SQ@k[D@][ZNWCUNEMUFFUM>MY]RDSVNZMSQSW	sx{vuxgokkGWRkWBSB\_k i^@RNW_]kVSNAUsx{vuxgokkGWRkUFBG[ZLZN Gk i[LYRkLY]QU^@RNW_]kVSNAU@FAQ>I>>SUB\XXALLBWR W\F XR^N]SFX^UDZ^SGFZ >>>]R^EQW_ZP\[\_^S^R^N]SFX^UDZ^SGFZMV\Yk_]LXPMZU P_ZV]GO>[]\CNNBEZB[Q\APGU_GSMD@VNWCUNEM>FQ@AFZ>I>RkV [kV DU^_R^N]SFX^UDZ^SGFZ>[URLARkUQG\YPR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtGQ@k@FUZG]QZ@NWCUNEM  >Y_C_D^[YNR	RUXGQ>]RDRLSL^XYMUsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V  sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>Y@Z[D[X	>R[FZEULUkVE_	ZEULUkVE_ZEULUkVE_O>ZWE]AFQ]XQ	sx{vuxgokkGWRkVkFMXL ki\[YQkAFXNWCUNEMsx{vuxgokkGWRkLFUXCD_ k iLPRLW  UFFUMYLW ^L@N	
jNWCUNEM	
C[Q BXU	
RUXGQXSDQk^Y[_N[ 	
 >>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM]GkCDkQFF[FZWE]AFQ]XQO>]RZEULUkVE_			sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vsx{vuxgokkGWRkP_^ERR[k[ki>>W[Z@]ZAQ>I>\U^L A[FUBYXY	]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQZWE]AFQ]XQ>>]R\U^L A[FUBYXYHHsx{vuxgokkGWRkUFBG[ZLZN Gk i\U^L A[FUBYXYUFFUM        @FAQO>>>>]RZEULUkVE_			sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nsx{vuxgokkGWRkP_^ERR[k[ki>W[Z@]ZAQ>>I>Y@Z[D[X	\U^L A[FUBYXY>VFQU_>I>]RY@Z[D[X			[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UXSDQk^Y[_N[ >]RY@Z[D[X		Y@Z[D[XY_C_D^[YNR	@FAQ>>>]RY@Z[D[X		Y@Z[D[X
	O>>>@kPAVLREA^	^EQW_ZP\[\_^S^R^N]SFX^UDZ^SGFZMV\Yk_]LXPMNVZYSNB>]R@kPAVLREA^@kPAVLREA^	^EQW_ZP\[\_^S^R^N]SFX^UDZ^SGFZNVZYSNB>VYQk[ QU	sx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]G>>>>_XBXLMP LG	tSQ@k[D@][ZYLW ^L@N>@DLZUMWFP]D	RUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk i_XBXLMP LGsx{vuxgokkGWRkUAU[DUV]kWki_XBXLMP LGVYQk[ QUH			O>UAUC  k	]Z@sx{vuxgokkGWRkQDZV_ki_XBXLMP LGsx{vuxgokkGWRkUAU[DUV]kWki_XBXLMP LGH>@DLZUMWFP]D	UAUC  ksx{vuxgokkGWRkNWYM^SkLZ[BNkiUAUC  k
	sx{vuxgokkGWRkNWYM^SkLZ[BNkiUAUC  k	>I>]R@DLZUMWFP]DO>ADPU@Qk[D@][ZNWCUNEMVYQk[ QUHsx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Q BXU>tPQXQ@Qk[D@][ZC[Q BXU>IQXGQO>>>tADPU@Qk[D@][ZYLW ^L@NVYQk[ QUHsx{vuxgokkGWRkNWYM^SkLZ[BNkiHY@Z[D[XRS^]Q]]ZB@[U>>>>I>AZGQ@VYQk[ QU_XBXLMP LG@DLZUMWFP]DUAUC  k>]R@kPAVLREA^O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ C[Q BXU Y@Z[D[X>FQ@AFZ>I>[URLARkUQG\YPR^N]SFX^UDZ^SGFZ>RkV [kV DU^_R^N]SFX^UDZ^SGFZ>Z@SSV]@AXS]ZZY@FAQ>>>WU^YMASDXk_GG@FAQ>RDXM_FYRB	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >R[FQUW\UFFUMsx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZVZ[[SF]P]DGWUAZUG^RXEE_LEFL\FBO>>>tsx{vuxgokkGWRkSXVSWM_EQki^RXEE_LEFL\FBYLW ^L@NRDXM_FYRB>>>tsx{vuxgokkGWRkSXVSWM_EQki^RXEE_LEFL\FBRS^]Q]]ZB@[URDXM_FYRB>I>]RMY]RDSVNZMSQSWE]Y]QS]ZPR@GCWLVVG\WZFFAP[LYRkLY]QU>sx{vuxgoC[Q BXUi	>NAGECUZEWRLU VXW>>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ U_GSMD@VY@Z[D[X>FQ@AFZ>I>>>>I>]F_QRDX	SQ@k[D@][ZXSDQk^Y[_N[ >>>>]Rsx{vuxgokkGWRkCGC  VMVVk i]F_QRDXsx{vuxgokkGWRkUAU[DUV]kWki]F_QRDXsx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]GH			PQXQ@Qk[D@][ZNWCUNEM>tsx{vuxgokkGWRkSXVSWM_EQkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZYLW ^L@N sx{vuxgokkGWRkk[AFM@ZWUECkiZU P_ZV]G>AZGQ@]F_QRDX>]RY_C_D^[YNRtPQXQ@Qk[D@][ZC[Q BXU>]RR \QMUkG[		O>>>sx{vuxgoXSDQk^Y[_N[ i	R \QMUkG[>>>>VFk\E[[BAL]CZR^N]SFX^UDZ^SGFZR \QMUkG[>I>]RAY_L_AMDFPN O>>>>CMk]SkZA	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >>>R[FQUW\UFFUMsx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZVZ[[SF]P]DGWUAZUG_]AZQYA E^GCXO>tsx{vuxgokkGWRkSXVSWM_EQki_]AZQYA E^GCXXSDQk^Y[_N[ CMk]SkZA>I>>>AZGQ@CMk]SkZA_]AZQYA E^GCX>I>YSWP_GN@FXXU_GSMD@VZU P_ZV]GRS^]Q]]ZB@[U>>>Z@SSV]@AXS]ZZY@FAQ>WU^YMASDXk_GG@FAQ>sx{vuxgoU_GSMD@Vi	>NAGECUZEWRLU VXW>SUB\XXALLBWR W\F XR^N]SFX^UDZ^SGFZ>]R[URLARkUQG\YPR^N]SFX^UDZ^SGFZCUB_YSQVGGNP[_BR^N]SFX^UDZ^SGFZ>ADPU@Qk[D@][ZU_GSMD@VR \QMUkG[Hsx{vuxgokkGWRkNWYM^SkLZ[BNkiXSDQk^Y[_N[ >IWU@W\`\F[CUVXQ[GD[EZLNO>>>>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>IR]ZUXXMO>L^U[US^\kM^RS^]Q]]ZB@[U>I>I>RAZW@][ZYY_ZPR\Y]@DMMWMW>O>]RPQR]ZQPRS^]Q]]ZB@[U HHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>]Rsx{vuxgokkGWRk\]XDEBSkWEkiuvgdu`|NWCUNEMO>FQEA]FQk[ZWQuvgdu`|YLW ^L@N>>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>FQ@AFZ>I>I>>>>_AUF]N UC^k	SQ@kDXAS]ZG>]Rsx{vuxgokkGWRkWBSB\_k i_AUF]N UC^kO>>>FQ@AFZ>I>X]G@	UFFUM>R[FQUW\_AUF]N UC^kUGVUGQZUYQ	
_DZRB@WFO>]RVUGQZUYQ			[LYRkLY]QUO>W[Z@]ZAQ>I>>X]G@oVUGQZUYQi	_DZRB@WF>I>FQ@AFZX]G@>>>>I>RAZW@][ZPE^AkBAPEEL^APZE[DCkFR]DQPADYVPDMNBC]>>O>>AX\PUMENN\	tsx{vuxgokkGWRkBYEVDGkUNk iZE[DCkFR]RUXGQZAXX >]RAX\PUMENN\O>FQ@AFZRUXGQ>>>>I>>R[FQUW\DQPADYVPDMNBC]UGk_ Pk]B_LO>>]Rsx{vuxgokkGWRkCGC  VMVVk ik_ Pk]B_LHHk_ Pk]B_LHHsx{vuxgokkGWRkD@WYYENNCMMkkik_ Pk]B_L
 O>W[Z@]ZAQ>>>>I>>>>>@FMO>WCLB@]UG	tsx{vuxgokkGWRkUQ Y]ZXWDkik_ Pk]B_LAX\PUMENN\>>IWU@W\`\F[CUVXQY\XWSZ @YR^\O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ Y\XWSZ @YR^\>>>W[Z@]ZAQ>>IWU@W\qLWQD@][ZY\XWSZ @YR^\O>W[Z@]ZAQ>I>>>>>]RWCLB@]UGO>FQ@AFZ@FAQ>I>I>FQ@AFZRUXGQ>I>>RAZW@][ZYY^CXYkRN@MZkZPPDDXAS]ZkVUGQZUYQ>O>>>>DQPADYVPDMNBC]	sx{vuxgoRS^]Q]]ZB@[Ui>>>]Rsx{vuxgokkGWRkWBSB\_k iDQPADYVPDMNBC]HHQYD@MDQPADYVPDMNBC]O>FQ@AFZRUXGQ>I>]RPQR]ZQPC[Q BXU HHQYD@MDXAS]ZkVUGQZUYQHHsx{vuxgokkGWRkUAU[DUV]kWkiDXAS]ZkVUGQZUYQU_GSMD@V  		RUXGQO>FQ@AFZRUXGQ>I>>>DCPZkSGSNUN	cdkdxas}zkp}fDXAS]ZkVUGQZUYQ>]Rsx{vuxgokkGWRkWLGRkXNMY[kiDXAS]ZkVUGQZUYQ			O>ZEX_RLMUM C	UFFUMDCPZkSGSNUN>>IQXGQO>>>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN>]Rsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]HHsx{vuxgokkGWRkRGGEPZCXk iPLDRFkX ]D]@Y]O>FQ@AFZRUXGQ>I>ZEX_RLMUM C	EZ\GRD^GV@_kD\PPLDRFkX ]D]@Y]UFFUMNWCUNEMYLW ^L@N C[Q BXUYLW ^L@NYLW ^L@N>I>>>>>R[FQUW\ZEX_RLMUM CUGZE[DCkFR]O>]Rsx{vuxgokkGWRk@Y@R NPPDCC@kiZE[DCkFR]O>W[Z@]ZAQ>I>]RPE^AkBAPEEL^APZE[DCkFR]DQPADYVPDMNBC]O>>>>FQ@AFZ@FAQ>I>I>FQ@AFZRUXGQ>I>RAZW@][ZEZ\GRD^GV@_kD\PPLDRFkX ]D]@Y]QLURPGXCWC_AQLYZX@	A_M]G_FBG	ZAXXSAACU^DFU@	ZAXX>O>X]G@	UFFUM>]R_AQLYZX@
O>FQ@AFZX]G@>I>]RA_M]G_FBG			ZAXXO>A_M]G_FBG	UFFUM>SAACU^DFU@	sx{vuxgokkGWRkPX^@X\kki@FAQj>>>>I>]Rsx{vuxgokkGWRkPX^@X\kki@FAQ
SAACU^DFU@O>>FQ@AFZX]G@>I>]Rsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]O>FQ@AFZX]G@>I>XkSFk\[LMkP	tsx{vuxgokkGWRkC]YQRGZkiPLDRFkX ]D]@Y]>>>]RXkSFk\[LMkP		RUXGQO>]R]GGQ@A_M]G_FBGoXkSFk\[LMkPiO>FQ@AFZX]G@>I>A_M]G_FBGoXkSFk\[LMkPi	@FAQ>I>RXFLCBWD	[FZWA_XLGNXRPLDRFkX ]D]@Y] >>>>]Rsx{vuxgokkGWRkWBSB\_k iRXFLCBWDO>FQ@AFZX]G@>I>>>R[FQUW\RXFLCBWDUGN@ S^VDL@QB O>>]Rsx{vuxgokkGWRkPX^@X\kki@FAQ
SAACU^DFU@HHsx{vuxgokkGWRkEMVLY\AkiX]G@
	LWL O>VFQU_>I>DCPZkSGSNUN	PLDRFkX ]D]@Y]N@ S^VDL@QB >]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iDCPZkSGSNUNO>W[Z@]ZAQ>I>]Rtsx{vuxgokkGWRkY  PFNk iDCPZkSGSNUNO>X]G@	sx{vuxgokkGWRkPE\P] W]XPFFAkiX]G@EZ\GRD^GV@_kD\PDCPZkSGSNUNQLURPGXCWC_AQLYZX@A_M]G_FBGSAACU^DFU@>IQXGQ]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>EFVXSRNPFREF^Y	sx{vuxgokkGWRk[\CPGL _]GZkiDCPZkSGSNUNW[ZG@UZ@NWCUNEM>>>EFVXSRNPFREF^Y	sx{vuxgokkGWRkCGC  VMVVk iEFVXSRNPFREF^Ysx{vuxgokkGWRkX@FXkiEFVXSRNPFREF^Y>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iEFVXSRNPFREF^YQLURPGXCWC@FAQO>X]G@oi	DCPZkSGSNUN>I>I>I>FQ@AFZX]G@>I>>RAZW@][ZSY^E UEN B^PLBDXAS]ZkVUGQZUYQ>>>O>>>]Rsx{vuxgokkGWRkCGC  VMVVk iDXAS]ZkVUGQZUYQHHDXAS]ZkVUGQZUYQO>FQ@AFZRUXGQ>I>>>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiDXAS]ZkVUGQZUYQXSDQk^Y[_N[   		RUXGQO>FQ@AFZRUXGQ>I>>>>>DXAS]ZkVUGQZUYQ	sx{vuxgokkGWRk\G[ML]GWkiDXAS]ZkVUGQZUYQ>]RDXAS]ZkVUGQZUYQ			[LYRkLY]QUO>FQ@AFZRUXGQ>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU sx{vuxgokkGWRk\]XDEBSkWEkiuvgdu`|YLW ^L@NO>>>FQEA]FQk[ZWQuvgdu`|YLW ^L@N>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N]GkDXAS]ZkUW@]BQDXAS]ZkVUGQZUYQO>PQUW@]BU@QkDXAS]ZGUFFUMDXAS]ZkVUGQZUYQ@FAQ>I>>>>PLDRFkX ]D]@Y]	PQR]ZQPU_GSMD@V cdkdxas}zkp}fsx{vuxgokkGWRkWLGRkXNMY[kiDXAS]ZkVUGQZUYQ>]RPLDRFkX ]D]@Y]sx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]sx{vuxgokkGWRkWLGRkXNMY[kiDXAS]ZkVUGQZUYQ		sx{vuxgokkGWRkWLGRkXNMY[kiDXAS]ZkVUGQZUYQO>]RSG\^@AEQYDMPLDRFkX ]D]@Y]O>FQ@AFZ@FAQ>I>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHWAFFQZ@kAGQFkWUZYLW ^L@NO>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>AGQFG	SQ@kAGQFGUFFUMU_GSMD@V	
XSDQk^Y[_N[ U_GSMD@V	
>]RQYD@MAGQFGAGQFGoi
}pO>sx{vuxgokkGWRk@F@ASEQ_P[FNkiAGQFGoi
}p>IQXGQO>sx{vuxgokkGWRk@F@ASEQ_P[FNki>I>I>I>>>>>XXk^[U	PQXQ@QkDXAS]ZGUFFUMDXAS]ZkVUGQZUYQ>]R]GkCDkQFF[FXXk^[UO>>FQ@AFZV[[XXXk^[U>I>I>FQ@AFZRUXGQ>>I>>RAZW@][ZSG\^@AEQYDMPLDRFkX ]D]@Y]_AQLYZX@	>>>O>]R_AQLYZX@
LWL O>FQ@AFZRUXGQ>I>]Rsx{vuxgokkGWRkCGC  VMVVk iPLDRFkX ]D]@Y]HHPLDRFkX ]D]@Y]			HHsx{vuxgokkGWRkUAU[DUV]kWkiPLDRFkX ]D]@Y]YLW ^L@N  		RUXGQO>FQ@AFZRUXGQ>>>>I>SZVD]MPkWk_FD	tsx{vuxgokkGWRkC]YQRGZkiPLDRFkX ]D]@Y]>]RSZVD]MPkWk_FD			RUXGQHHsx{vuxgokkGWRkY  PFNk iSZVD]MPkWk_FDO>FQ@AFZRUXGQ>I>DQDQQ@]E]MRAPk	PQR]ZQPYLW ^L@N tsx{vuxgokkGWRkC]YQRGZkicdkdxas}zkp}fRUXGQ>>>]RDQDQQ@]E]MRAPk			RUXGQHHSZVD]MPkWk_FD		DQDQQ@]E]MRAPksx{vuxgokkGWRkUAU[DUV]kWkiSZVD]MPkWk_FDDQDQQ@]E]MRAPkp}fqw`{fmkgqdufu`{f		O>FQ@AFZRUXGQ>>>>I>>C^VBMP_RLULMA	tsx{vuxgokkGWRkZ][LAE N FkiSZVD]MPkWk_FD>]Rsx{vuxgokkGWRkWBSB\_k iC^VBMP_RLULMAO>FQ@AFZRUXGQ>>>I>R[FQUW\C^VBMP_RLULMAUGLWRBBEkLSO>>]RLWRBBEkLS			HHLWRBBEkLS			C[Q BXU  O>W[Z@]ZAQ>>>>I>>DCPZkSGSNUN	SZVD]MPkWk_FDW[ZG@UZ@NWCUNEMLWRBBEkLS>]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iDCPZkSGSNUNO>UC[WM Z DCPZkSGSNUN>W[Z@]ZAQ>I>>>>]Rtsx{vuxgokkGWRkY  PFNk iDCPZkSGSNUNO>SG\^@AEQYDMDCPZkSGSNUN_AQLYZX@>>IQXGQO>]RUC[WM Z DCPZkSGSNUNO>SUB\XXALLBWR W\F XDCPZkSGSNUNLULU>UC[WM Z DCPZkSGSNUN>I>I>I>]Rtsx{vuxgokkGWRkMk]XXW_UUQkiSZVD]MPkWk_FDO>SUB\XXALLBWR W\F XSZVD]MPkWk_FD >tsx{vuxgokkGWRkMk]XXW_UUQkiSZVD]MPkWk_FD>I>FQ@AFZtsx{vuxgokkGWRk\]XDEBSkWEkiSZVD]MPkWk_FD>I>>>>>>RAZW@][ZP][M_RWPV]SU]F>O>>@FMO>>X]G@	YY_ZPR\Y]@DMMWMW>]Rsx{vuxgokkGWRkWBSB\_k iX]G@O>FQ@AFZ>I>>_EDL V[Rk	UFFUM>>>>\@QB_NY^	RUXGQ>R[FQUW\sx{vuxgokkGWRk]UFVD[U \kiX]G@UGVUGQZUYQO>>]Rsx{vuxgokkGWRkCGC  VMVVk iVUGQZUYQO>W[Z@]ZAQ>I>>SLG]XSCCVA	sx{vuxgokkGWRkWLGRkXNMY[kiVUGQZUYQ>>>>]RSLG]XSCCVA			O>SLG]XSCCVA	VUGQZUYQ>I>]R]GGQ@_EDL V[RkoSLG]XSCCVAiO>>>W[Z@]ZAQ>I>>_EDL V[RkoSLG]XSCCVAi	@FAQ>]RYY^CXYkRN@MZkZPPDVUGQZUYQO>SY^E UEN B^PLBVUGQZUYQ>\@QB_NY^	@FAQ>I>I>>]Rtsx{vuxgokkGWRkY  PFNk iVZ[[SF]P]DGWUAZO>W^P@S^DPG	[FZWA_XLGNXRVZ[[SF]P]DGWUAZ >]Rsx{vuxgokkGWRkWBSB\_k iW^P@S^DPGO>>>>DQPADYVPDMNBC]	sx{vuxgoRS^]Q]]ZB@[Ui>R[FQUW\W^P@S^DPGUGN@ S^VDL@QB O>>>>]RN@ S^VDL@QB 			\ASSNCBDS[ZG^O>W[Z@]ZAQ>I>>>ZE[DCkFR]	VZ[[SF]P]DGWUAZN@ S^VDL@QB >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiZE[DCkFR]HHsx{vuxgokkGWRkX@FXkisx{vuxgokkGWRk[\CPGL _]GZkiN@ S^VDL@QB W[ZG@UZ@NWCUNEM		XSDQk^Y[_N[  O>W[Z@]ZAQ>I>>>>>>>]RPE^AkBAPEEL^APZE[DCkFR]DQPADYVPDMNBC]O>UC[WM Z ZE[DCkFR]>\@QB_NY^	@FAQ>I>I>I>I>>AL[MB^L	sx{vuxgoNWCUNEM i>]Rsx{vuxgokkGWRkWBSB\_k iAL[MB^LQYD@MAL[MB^LO>]RCQZQM@LUDPCQGCWL]AL[MB^LO>\@QB_NY^	@FAQ>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>RAZW@][ZMVZ[ZC[DNMDVQ>O>@FMO>RCN^kD_AE]Q	]Z@SQ@k[D@][ZRS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkNWYM^SkLZ[BNkiRCN^kD_AE]Q
	LLQO>ADPU@Qk[D@][ZRS^]Q]]ZB@[Usx{vuxgokkGWRkNWYM^SkLZ[BNki>_[N ZA[D[Z\^_	UFFUMUFFUMWVEU\YGLXM[FUNCUFFUMNWCUNEM>G[XMQ@QLRDLMCX 	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMsx{vuxgokkGWRkLBBNYWPX^Dki>]RG[XMQ@QLRDLMCX 		G[XMQ@QLRDLMCX 		WVEU\YGLXM[FUNC_[N ZA[D[Z\^_oi	UFFUMG[XMQ@QLRDLMCX UFFUMRS^]Q]]ZB@[UYLW ^L@N>R[FQUW\_[N ZA[D[Z\^_UGU@AQDW\BS[SO>R[FQUW\U@AQDW\BS[SoiUGUSL @\DO>QR_FXVWFMED	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tsx{vuxgokkGWRkV^E_YEEGLMVkiU@AQDW\BS[SoiUSL @\DRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iQR_FXVWFMEDW[Z@]ZAQ>R[FQUW\QR_FXVWFMEDUGYXVVZQ]@QAU[O>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiYXVVZQ]@QAU[W[Z@]ZAQ>>]Rsx{vuxgokkGWRkQDZV_kiYXVVZQ]@QAU[ 			YLW ^L@N W[Z@]ZAQ>PXXE]UPNN	tsx{vuxgokkGWRkUMX_NCYCkiYXVVZQ]@QAU[>]RPXXE]UPNN		RUXGQsx{vuxgokkGWRkNWYM^SkLZ[BNkiPXXE]UPNN
   UC[WM Z YXVVZQ]@QAU[>I>>>>I>I>>>^@RNW_]kVSNAU	SQ@k[D@][ZNWCUNEMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k i^@RNW_]kVSNAU^@RNW_]kVSNAU	UFFUM>>>>BVVF^]_	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N>kDP	PQR]ZQPU_GSMD@V cdkw{z`qz`kp}fuvgdu`|RS^]Q]]ZB@[UXSDQk^Y[_N[ >R[FQUW\sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NUFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkikDPXSDQk^Y[_N[ UFFUMUGEY\BBGk UQRO>]Rsx{vuxgokkGWRkQANE SG_kXV\kisx{vuxgokkGWRkWLGRkXNMY[kiEY\BBGk UQR			BVVF^]_W[Z@]ZAQ>XL\@[@VUX_NAEW	sx{vuxgokkGWRkQANE SG_kXV\kisx{vuxgokkGWRkWLGRkXNMY[kiEY\BBGk UQRsx{vuxgokkGWRkQANE SG_kXV\kiEY\BBGk UQR>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iXL\@[@VUX_NAEW^@RNW_]kVSNAU@FAQW[Z@]ZAQ>]Rtsx{vuxgokkGWRk_XXP] C^Mk iEY\BBGk UQRW[Z@]ZAQ>\YC]ZCSV	tsx{vuxgokkGWRkDNNU_UYWXVVkiEY\BBGk UQR>>>]R\YC]ZCSVHH\YC]ZCSV
   W[Z@]ZAQ>\U^L A[FUBYXY	tsx{vuxgokkGWRkBYEVDGkUNk iEY\BBGk UQR>]Rsx{vuxgokkGWRkCGC  VMVVk i\U^L A[FUBYXYHHsx{vuxgokkGWRkUAU[DUV]kWki\U^L A[FUBYXYNWCUNEM 			RUXGQW[Z@]ZAQ>M[DVE@MZA\XE	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[U \U^L A[FUBYXY>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iM[DVE@MZA\XEHHM[DVE@MZA\XE			\U^L A[FUBYXYHHM[YQk NNVYMFB\M[DVE@MZA\XEW[Z@]ZAQ>^EQW_ZP\[\_^S^EY\BBGk UQRM[DVE@MZA\XE>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vt[DWUW\Qk]ZBUX]PU@QEY\BBGk UQR@FAQ>I>AZGQ@^@RNW_]kVSNAUBVVF^]_kDPEY\BBGk UQRXL\@[@VUX_NAEW\YC]ZCSV\U^L A[FUBYXYM[DVE@MZA\XE>AYAB LSXGWVRFMk]WA>I>>SZFN SQGXC	sx{vuxgoU_GSMD@V i>>>>AL[MB^L	sx{vuxgoXSDQk^Y[_N[  i>>>>>@CRkNNS LS	sx{vuxgokkGWRkWBSB\_k iSZFN SQGXCQYD@MSZFN SQGXCHHsx{vuxgokkGWRkWBSB\_k iAL[MB^LQYD@MAL[MB^L>]R@CRkNNS LSO>FQ@AFZ>I>>>^^PZ[XNC	]Z@SQ@k[D@][ZNWCUNEM >]Rsx{vuxgokkGWRkNWYM^SkLZ[BNki^^PZ[XNC O>FQ@AFZ>I>]RPZEURB[UWFUPYLW ^L@N  O>FQ@AFZ>I>>@FMO>^^PZ[XNC	]Z@SQ@k[D@][ZNWCUNEM >]Rsx{vuxgokkGWRkNWYM^SkLZ[BNki^^PZ[XNC O>>FQ@AFZ>I>ADPU@Qk[D@][ZYLW ^L@N sx{vuxgokkGWRkNWYM^SkLZ[BNki>P][M_RWPV]SU]F>IR]ZUXXMO>L^U[US^\kM^C[Q BXU >I>>>IWU@W\`\F[CUVXQ[GD[EZLNO>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>I>I>>RAZW@][ZFFRWS_XSLA_^LCGXM>>>>O>@FMO>>Rk[NLS^]	Z@SSV]@AXS]ZZY>>>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^] FQ@AFZ>]RM[YQk NNVYMFB\Rk[NLS^]O>>>[]\CNNBEZB[Q\APGYLW ^L@N C[Q BXU >FQ@AFZ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U SQ@k@FUZG]QZ@U_GSMD@VFQ@AFZ>>BRMUD]WD	VZ[[SF]P]DGWUAZ>WXQUFG@U@WUW\Q@FAQ>]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iBRMUD]WDtsx{vuxgokkGWRkY  PFNk iBRMUD]WDO>FQ@AFZ>>I>>>>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDO>>>>GV_DUG_PD\_	tAYUG_>GEWVN@XUE@ P\\ZBRMUD]WD @FAQ>tAYUG_GV_DUG_PD\_>>>>SUB\XXALLBWR W\F XBRMUD]WD >WXQUFG@U@WUW\Q@FAQ>>IQXGQ]Rtsx{vuxgokkGWRkRGGEPZCXk iBRMUD]WDHHtsx{vuxgokkGWRk_XXP] C^Mk iBRMUD]WDO>SUB\XXALLBWR W\F XBRMUD]WD >WXQUFG@U@WUW\Q@FAQ>>>>I>>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDtsx{vuxgokkGWRkRGGEPZCXk iBRMUD]WDHHtsx{vuxgokkGWRk_XXP] C^Mk iBRMUD]WDtsx{vuxgokkGWRkMk]XXW_UUQkiBRMUD]WDO>GV_DUG_PD\_	tAYUG_>>GEWVN@XUE@ P\\ZBRMUD]WD @FAQ>tAYUG_GV_DUG_PD\_>SUB\XXALLBWR W\F XBRMUD]WD >WXQUFG@U@WUW\Q@FAQ>I>>WXQUFG@U@WUW\Q@FAQ>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDHHtsx{vuxgokkGWRk_XXP] C^Mk iBRMUD]WDHHtsx{vuxgokkGWRkRGGEPZCXk iBRMUD]WDO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U XSDQk^Y[_N[ >>_SRRABDFC 	RUXGQ>R[FQUW\UFFUMsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Ntsx{vuxgokkGWRkV^E_YEEGLMVkiBRMUD]WDYLW ^L@NUFFUMUGYRARS^NPRENO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiYRARS^NPRENkACM_XP_VCUZ YkLYRARS^NPREN G[V]FSPk\ Z]^AB_PYRARS^NPRENOCBZR\RDFU\DVGMSkGYRARS^NPREN_SRRABDFC 	@FAQI>I>>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDQ^YGW\LCNk[ZNZAXXO>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtPQXQ@Qk@FUZG]QZ@C[Q BXU>WXQUFG@U@WUW\Q@FAQ>>>>I>]Rtsx{vuxgokkGWRkY  PFNk iBRMUD]WDHHtsx{vuxgokkGWRk_XXP] C^Mk iBRMUD]WDHHtsx{vuxgokkGWRkRGGEPZCXk iBRMUD]WDO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tGQ@k@FUZG]QZ@XSDQk^Y[_N[ _SRRABDFC >AZGQ@_SRRABDFC YRARS^NPREN>FQ@AFZ>I>AZGQ@_SRRABDFC YRARS^NPREN>>>>I>>>DBZQDBR[@	BRMUD]WD\ASSNCBDS[ZG^>]RV@  NBWM[ML[CDBZQDBR[@O>>>FQ@AFZ>>I>WVAQ][ MBN[V	tsx{vuxgokkGWRk@Y@R NPPDCC@kiDBZQDBR[@SFFMRN]XGWQNDBZQDBR[@RUXGQ>]Rtsx{vuxgokkGWRkDNNU_UYWXVVkiDBZQDBR[@
LRLsx{vuxgokkGWRkCGC  VMVVk iWVAQ][ MBN[Vsx{vuxgokkGWRkk[AFM@ZWUECkiWVAQ][ MBN[V			sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]O>RkV [kV DU^_DBZQDBR[@>SLXEXL ZZA^Y>\BW^]C W]NPM>FQ@AFZ>I>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDBZQDBR[@tsx{vuxgokkGWRkDNNU_UYWXVVkiDBZQDBR[@
LPLVO>\SFD@CP\@	G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iDBZQDBR[@RUXGQZAXX  >]Rsx{vuxgokkGWRkCGC  VMVVk i\SFD@CP\@sx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ \SFD@CP\@kPYBQFG][ZkW[YDUFQkPYoiXCDS]V]N]\U[DX C
FQ@AFZ>AZGQ@\SFD@CP\@kPY>I>]RWVAQ][ MBN[V			ZAXXFQ@AFZ>>AZGQ@WVAQ][ MBN[V>>CVAPFRRXRA	^EQW_ZP\[\_^S^DBZQDBR[@MV\Yk_]LXPMRk[NLS^]>>>>]RCVAPFRRXRAHHtsx{vuxgokkGWRk\]XDEBSkWEkiDBZQDBR[@HHtsx{vuxgokkGWRkDNNU_UYWXVVkiDBZQDBR[@LLO>]RCVAPFRRXRAtsx{vuxgokkGWRk@Y@R NPPDCC@kiDBZQDBR[@O>\SFD@CP\@	G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iDBZQDBR[@RUXGQZAXX  >Q@FGP MA\	sx{vuxgokkGWRkCGC  VMVVk i\SFD@CP\@sx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXU \SFD@CP\@kPYBQFG][ZkW[YDUFQkPYoiXCDS]V]N]\U[DX C
>AZGQ@\SFD@CP\@kPY>]RQ@FGP MA\O>SUB\XXALLBWR W\F XDBZQDBR[@>UC[WM Z DBZQDBR[@>I>I>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtGQ@k@FUZG]QZ@NWCUNEMLPVL>FQ@AFZ>I>>>>CUB_YSQVGGNP[_BDBZQDBR[@>SUB\XXALLBWR W\F XDBZQDBR[@>>>RkV [kV DU^_DBZQDBR[@>>>SLXEXL ZZA^Y>\BW^]C W]NPM>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>>I>I>RAZW@][ZUF@PLF@XkFD^P>O>>>>@FMO>DNCYRUSFYM\\	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ ]Z@SQ@k[D@][ZYLW ^L@N>>]RDNCYRUSFYM\\sx{vuxgokkGWRkNWYM^SkLZ[BNkiHHDNCYRUSFYM\\
sx{vuxgokkGWRkNWYM^SkLZ[BNkiO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU tADPU@Qk[D@][ZXSDQk^Y[_N[ sx{vuxgokkGWRkNWYM^SkLZ[BNki>GV_DUG_PD\_	M_E@QREC][XSDQk^Y[_N[ >[EADQD@C\@	D^\[ GECU_NDSQ]_FXsx{vuxgokkGWRkCGC  VMVVk iGV_DUG_PD\_GV_DUG_PD\_>GQX@P Z	XM\@\EXW]R^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iGV_DUG_PD\_HHsx{vuxgokkGWRkD@WYYENNCMMkkiGV_DUG_PD\_ HHXABG]WV@AL\GV_DUG_PD\_HH[EADQD@C\@			HHGQX@P Z		ZAXXGQX@P Z		BQFG][ZkW[YDUFQGQX@P Z[EADQD@C\@
O>Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]XABG]WV@AL\Rk[NLS^]O>>DB QRELVFCN@]VV\	D^\[ GECU_NDSQ]_FXRk[NLS^]>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iGV_DUG_PD\_HHsx{vuxgokkGWRkD@WYYENNCMMkkiGV_DUG_PD\_HHXABG]WV@AL\GV_DUG_PD\_HH[EADQD@C\@			HHDB QRELVFCN@]VV\		BQFG][ZkW[YDUFQDB QRELVFCN@]VV\[EADQD@C\@
O>YSWP_GN@FXXNWCUNEMRk[NLS^]XSDQk^Y[_N[ >]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU O>>>tADPU@Qk[D@][ZYLW ^L@NC[Q BXU>tADPU@Qk[D@][ZRS^]Q]]ZB@[UU_GSMD@V>tADPU@Qk[D@][ZC[Q BXU NWCUNEM>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtPQXQ@Qk@FUZG]QZ@DPAZGEVRQCQ_>I>I>I>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Usx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>F^YX[XL_Z\	SQ@k[D@][ZC[Q BXU>]RF^YX[XL_Z\		RUXGQF^YX[XL_Z\		XCDS]V]N]\U[DX CO>tADPU@Qk[D@][ZYLW ^L@NXCDS]V]N]\U[DX CYLW ^L@N>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMHHUPPk[D@][ZC[Q BXUXCDS]V]N]\U[DX CXSDQk^Y[_N[ O>FQ@AFZ>I>>RW_VBDDPP[]EME>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM O>tADPU@Qk[D@][ZU_GSMD@VU_GSMD@V>tADPU@Qk[D@][ZNWCUNEMRS^]Q]]ZB@[U>tADPU@Qk[D@][ZRS^]Q]]ZB@[U RS^]Q]]ZB@[U>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  tPQXQ@Qk@FUZG]QZ@DPAZGEVRQCQ_>>]RQYD@MRk[NLS^]XABG]WV@AL\Rk[NLS^]O>YSWP_GN@FXXRS^]Q]]ZB@[URk[NLS^]RS^]Q]]ZB@[U>I>@WRYSCWMRD]^PLZAXX>>>SUB\XXALLBWR W\F XR^N]SFX^UDZ^SGFZ >>>>VMR^VBCUFWXDRS^]Q]]ZB@[U NWCUNEM >>VMR^VBCUFWXDU_GSMD@V U_GSMD@V>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tPQXQ@Qk[D@][ZU_GSMD@V>IWU@W\qLWQD@][Z[GD[EZLNO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tPQXQ@Qk[D@][ZC[Q BXU>I>I>>>RAZW@][ZQXQMW @FSk>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU  O>tsx{vuxgokkGWRkVkFMXL ki\[YQkAFXUFFUMC[Q BXU	
 NWCUNEM	
RUXGQXSDQk^Y[_N[  	
RUXGQ>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>RAZW@][ZX\_E_CNQQA\ZLE@>O>G@U@]W]RW]GUFGYM^	RUXGQ>>>]R]RW]GUFGYM^FQ@AFZ>]RW]GUFGYM^	@FAQ>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUHH]GkUPY]ZO>FQ@AFZ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VHHWAFFQZ@kAGQFkWUZYLW ^L@N O>FQ@AFZ>>>I>RMYZQVWN]FE	]GGQ@kfqeaqg`oNWCUNEMikfqeaqg`oRS^]Q]]ZB@[Ui>RMYZQVWN]FE	sx{vuxgokkGWRkCGC  VMVVk iRMYZQVWN]FEsx{vuxgokkGWRk\G[ML]GWkiRMYZQVWN]FE>>>>]RRMYZQVWN]FE		RS^]Q]]ZB@[URMYZQVWN]FE		XSDQk^Y[_N[ O>FQ@AFZ>I>>@[kP_GNL	UFFUM>]RRMYZQVWN]FE			RS^]Q]]ZB@[UO>ECFUXZN\F@N	]GGQ@kfqeaqg`oC[Q BXUikfqeaqg`oXSDQk^Y[_N[ i>ECFUXZN\F@N	sx{vuxgokkGWRkCGC  VMVVk iECFUXZN\F@Nsx{vuxgokkGWRk\G[ML]GWkiECFUXZN\F@N>]RECFUXZN\F@NECFUXZN\F@N		[LYRkLY]QUO>@[kP_GNLoi	ECFUXZN\F@N>I>>>IQXGQO>>>>>YFk XSE^kC	]GGQ@kfqeaqg`oU_GSMD@Vikfqeaqg`oRS^]Q]]ZB@[UiUFFUM>YFk XSE^kC	sx{vuxgokkGWRkWBSB\_k iYFk XSE^kCYFk XSE^kCUFFUM>R[FQUW\YFk XSE^kCUGECFUXZN\F@NO>ECFUXZN\F@N	sx{vuxgokkGWRkCGC  VMVVk iECFUXZN\F@Nsx{vuxgokkGWRk\G[ML]GWkiECFUXZN\F@N>]RECFUXZN\F@NECFUXZN\F@N		[LYRkLY]QUO>@[kP_GNLoi	ECFUXZN\F@N>>>I>I>I>]RQYD@M@[kP_GNLO>FQ@AFZ>I>\@QB_NY^	RUXGQ>R[FQUW\@[kP_GNLUGECFUXZN\F@NO>]RYY^CXYkRN@MZkZPPDECFUXZN\F@NO>SY^E UEN B^PLBECFUXZN\F@N>\@QB_NY^	@FAQ>I>I>]R\@QB_NY^O>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>CDkGURQkFQP]FQW@UPY]ZkAFXU_GSMD@V>I>>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>[]\CNNBEZB[Q\APGC[Q BXU[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>RAZW@][Z_LWXW[BYWD[WPM[VPYSS]k^W]ZZCQMYZ>O>]R^W]ZZCQMYZ			NWCUNEM O>DXAS]ZG	sx{vuxgoC[Q BXUi>]R]GGQ@DXAS]ZGoXSDQk^Y[_N[  iHHsx{vuxgokkGWRkWBSB\_k iDXAS]ZGoRS^]Q]]ZB@[U iO>FQ@AFZD[WPM[VPYSS]k>I>QVP^RXVQX	PQR]ZQPNWCUNEMcdkw{z`qz`kp}fPQR]ZQPYLW ^L@Nuvgdu`|YLW ^L@N>]RQVP^RXVQX			O>FQ@AFZD[WPM[VPYSS]k>I>]X]YF@WMGN	UFFUMNWCUNEM	
U_GSMD@VNWCUNEM	
C[Q BXU>>>>R[FQUW\]X]YF@WMGNUG\\^WNCFG	
USL @\DO>]R]GGQ@DXAS]ZGoNWCUNEMio\\^WNCFGiO>>>W[Z@]ZAQ>I>>>>E[V@QkBM	tsx{vuxgokkGWRkBYEVDGkUNk iQVP^RXVQX\\^WNCFG>>>]Rsx{vuxgokkGWRkCGC  VMVVk iE[V@QkBMHHsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMU_GSMD@VUSL @\DU_GSMD@V 			RUXGQO>>>W[Z@]ZAQ>>>>I>>>DC_SSQWSRU	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[UUSL @\DRS^]Q]]ZB@[UUSL @\DC[Q BXUE[V@QkBM>]Rsx{vuxgokkGWRkCGC  VMVVk iDC_SSQWSRUO>W[Z@]ZAQ>I>DC_SSQWSRU	sx{vuxgokkGWRk\G[ML]GWkiDC_SSQWSRU>]RDC_SSQWSRU			HHDC_SSQWSRU			NWCUNEMHHDC_SSQWSRU			U_GSMD@V O>AZGQ@DXAS]ZGoRS^]Q]]ZB@[Uio\\^WNCFGi>I>I>FQ@AFZD[WPM[VPYSS]k>I>]R^W]ZZCQMYZ		RS^]Q]]ZB@[UO>FQ@AFZD[WPM[VPYSS]k>I>>DXAS]ZG	sx{vuxgoC[Q BXUi>RA]@_EWYVN\P	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>]R]GGQ@DXAS]ZGoNWCUNEMioRA]@_EWYVN\PiO>AZGQ@DXAS]ZGoU_GSMD@VioRA]@_EWYVN\Pi>I>FQ@AFZD[WPM[VPYSS]k>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>RAZW@][ZYLBW_k^PLE^ ANNk@L^X>O>>>>]RE]Y]QS]ZPR@GO>FQ@AFZ>I>>@WS\XZ[Qk	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >][E@@SAB ZN_E	kMZ[W\L[YU[@WS\XZ[Qk>QW\[RS^]Q]]ZB@[UQGWkU@@F@WS\XZ[QkRS^]Q]]ZB@[UQGWkU@@F][E@@SAB ZN_ERS^]Q]]ZB@[U>QW\[C[Q BXU QGWk^G@WS\XZ[QkYLW ^L@NQGWk^G][E@@SAB ZN_EXSDQk^Y[_N[ >I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>RAZW@][Z@_EZBXDVZSVCM[XND@C>>O>]Rsx{vuxgokkGWRk@L\SQY@ZAkiM[XND@CO>FQ@AFZM[XND@C>I>@WS\XZ[Qk	[LYRkLY]QU>]R]GGQ@M[XND@C
FQGD[ZGQo@WS\XZ[QkiO>>>>AZGQ@M[XND@C
FQGD[ZGQo@WS\XZ[Qki>I>>>FQ@AFZM[XND@C>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>RAZW@][ZE\PDLPDFGPU_ZZ@YSDXAS]ZG>>>>O>M YGAF^PE@ZQB	[LYRkLY]QU>]R]GGQ@DXAS]ZGoM YGAF^PE@ZQBiO>AZGQ@DXAS]ZGoM YGAF^PE@ZQBi>I>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZC[Q BXU>][E@@SAB ZN_E	kMZ[W\L[YU[sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>]R]GGQ@DXAS]ZGo][E@@SAB ZN_EiO>AZGQ@DXAS]ZGo][E@@SAB ZN_Ei>I>>>>FQ@AFZDXAS]ZG>>>I>>>I>RAZW@][ZZY@WXkWZEL]QDMFkLA_Y Ak^QG\>O>]Rsx{vuxgokkGWRkWBSB\_k iFkLA_Y Ak^QG\O>FQ@AFZFkLA_Y Ak^QG\>I>RY_[VQ_	>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vsx{vuxgokkGWRk\]XDEBSkWEkiR^N]SFX^UDZ^SGFZO>XRVXBWS \@@@	SQ@kDXAS]ZkPU@UR^N]SFX^UDZ^SGFZRUXGQRUXGQ>>>>RY_[VQ_	]GGQ@XRVXBWS \@@@oRS^]Q]]ZB@[UiXRVXBWS \@@@oYLW ^L@Ni>I>ZEXC_@S\N\^	UFFUMRS^]Q]]ZB@[UU_GSMD@V>R[FQUW\ZEXC_@S\N\^UGBENDLBVSQSCPPO>]R]GGQ@FkLA_Y Ak^QG\oBENDLBVSQSCPPioYLW ^L@NiHHsx{vuxgokkGWRkWBSB\_k iFkLA_Y Ak^QG\oBENDLBVSQSCPPioYLW ^L@NiO>W[Z@]ZAQ>I>>>>R[FQUW\FkLA_Y Ak^QG\oBENDLBVSQSCPPioNWCUNEMiUG_QM	
YFEBGPG GCVO>]Rsx{vuxgokkGWRkUAU[DUV]kWki_QM[LYRkLY]QU		RUXGQHH_QM			[LYRkLY]QUO>AZGQ@FkLA_Y Ak^QG\oBENDLBVSQSCPPioXSDQk^Y[_N[ io_QMi>W[Z@]ZAQ>>I>]RRY_[VQ_		_QM			RY_[VQ_O>AZGQ@FkLA_Y Ak^QG\oBENDLBVSQSCPPioU_GSMD@Vio_QMi>W[Z@]ZAQ>I>I>>>I>>>R[FQUW\UFFUMU_GSMD@V XSDQk^Y[_N[ UG\RBUCB[]C@O>^F^_[EM 	]GGQ@FkLA_Y Ak^QG\o\RBUCB[]C@ioRS^]Q]]ZB@[Uisx{vuxgokkGWRkWBSB\_k iFkLA_Y Ak^QG\o\RBUCB[]C@ioU_GSMD@ViFkLA_Y Ak^QG\o\RBUCB[]C@ioXSDQk^Y[_N[ iUFFUM>]R^F^_[EM W[Z@]ZAQ>>>>CN]_AF N	PQR]ZQPC[Q BXUcdyakdxas}zkp}fPQR]ZQPRS^]Q]]ZB@[Ucdkw{z`qz`kp}fC[Q BXU>@ NWZU	UFFUM>]RRY_[VQ_		@ NWZUoi	RY_[VQ_>@ NWZUoi	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>]RCN]_AF N		tsx{vuxgokkGWRkY  PFNk iCN]_AF Nsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiCN]_AF NNWCUNEMUGYRARS^NPRENO>N_QFQSGPkGSL]	tsx{vuxgokkGWRkBYEVDGkUNk iYRARS^NPRENRUXGQZAXX  >]Rsx{vuxgokkGWRkCGC  VMVVk iN_QFQSGPkGSL]HHsx{vuxgokkGWRkUAU[DUV]kWkiN_QFQSGPkGSL]C[Q BXU			RUXGQW[Z@]ZAQ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ N_QFQSGPkGSL]]\_M]VGQVO>SSCXSG@ZEDL	sx{vuxgokkGWRk\G[ML]GWki]\_M]VGQVoi>>]RSSCXSG@ZEDL		@ NWZUoi	SSCXSG@ZEDL>>>>I>>>@ NWZUoi	sx{vuxgokkGWRkQANE SG_kXV\kiYRARS^NPREN>I>>>>I>R[FQUW\^F^_[EM UG_QM	
YFEBGPG GCVO>R[FQUW\@ NWZUUG\kRXXNGZLCZAO>]R_QM			\kRXXNGZLCZAHH_QM			GUZ]@]NQk@QL@kR]QXP\kRXXNGZLCZAO>>AZGQ@FkLA_Y Ak^QG\o\RBUCB[]C@ioU_GSMD@Vio_QMi>VFQU_>>I>I>I>I>FLDFAFX W@@@	]GGQ@FkLA_Y Ak^QG\oYLW ^L@NioXSDQk^Y[_N[ isx{vuxgokkGWRkWBSB\_k iFkLA_Y Ak^QG\oXSDQk^Y[_N[ ioU_GSMD@ViFkLA_Y Ak^QG\oXSDQk^Y[_N[ ioXSDQk^Y[_N[  iUFFUM>]RFLDFAFX W@@@O>QVP^RXVQX	PQR]ZQPYLW ^L@Ncdkw{z`qz`kp}fPQR]ZQPRS^]Q]]ZB@[Uuvgdu`|C[Q BXU>]X]YF@WMGN	UFFUMRS^]Q]]ZB@[U	
YLW ^L@NU_GSMD@V	
C[Q BXU>R[FQUW\FLDFAFX W@@@UG_QM	
YFEBGPG GCVO>>>>]R]GGQ@]X]YF@WMGNo_QMiHHQVP^RXVQX			W[Z@]ZAQ>E[V@QkBM	tsx{vuxgokkGWRkBYEVDGkUNk iQVP^RXVQX_QMRUXGQZAXXLP VLV>]Rsx{vuxgokkGWRkCGC  VMVVk iE[V@QkBMsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMRS^]Q]]ZB@[U]X]YF@WMGNo_QMiU_GSMD@V 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMXSDQk^Y[_N[ 		RUXGQO>AZGQ@FkLA_Y Ak^QG\oNWCUNEMioXSDQk^Y[_N[  io_QMi>I>I>I>FQ@AFZFkLA_Y Ak^QG\>I>>RAZW@][ZLV\LZQLE_LQSQBM]P ^G^[Q_FPN_>O>]Rsx{vuxgokkGWRkWBSB\_k i^G^[Q_FPN_O>FQ@AFZ^G^[Q_FPN_>I>kD\LQGAU	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>NFCA_APWM	sx{vuxgokkGWRk[\CPGL _]GZkikD\LQGAUdu`|}zr{kr}xqzuyq>>>GFCCMEMBEZ_	UFFUM>UFFUMYLW ^L@N	
sx{vuxgokkGWRkFSCP[[U^kikD\LQGAURS^]Q]]ZB@[UXSDQk^Y[_N[ 	
@FAQ>UFFUMC[Q BXU	
NWCUNEM sx{vuxgokkGWRkFSCP[[U^kiNFCA_APWMU_GSMD@VXSDQk^Y[_N[ 	
@FAQ>>]R]GGQ@^G^[Q_FPN_oRS^]Q]]ZB@[Uisx{vuxgokkGWRkWBSB\_k i^G^[Q_FPN_oNWCUNEMiO>>R[FQUW\^G^[Q_FPN_oU_GSMD@ViUGF^P_ NFVB	
DEWQ[_SQO>]Rsx{vuxgokkGWRkWBSB\_k iDEWQ[_SQHHsx{vuxgokkGWRkDCX^kkiF^P_ NFVBO>>W[Z@]ZAQ>I>]R]GGQ@^G^[Q_FPN_oYLW ^L@NioF^P_ NFVBioNWCUNEMiHHsx{vuxgokkGWRkWBSB\_k i^G^[Q_FPN_oRS^]Q]]ZB@[UioF^P_ NFVBioXSDQk^Y[_N[ iO>^G^[Q_FPN_oRS^]Q]]ZB@[UioF^P_ NFVBioC[Q BXUi	UFFUM>I>>R[FQUW\GFCCMEMBEZ_UG^kSDLS\SO>^G^[Q_FPN_oXSDQk^Y[_N[ ioF^P_ NFVBioXSDQk^Y[_N[ ioi	^kSDLS\S>I>I>I>FQ@AFZ^G^[Q_FPN_>I>>RAZW@][ZX\[WDG\PRR\R>O>@FMO>>>>]RPQR]ZQPU_GSMD@VHHW[ZG@UZ@YLW ^L@N O>FQ@AFZ>I>>>]Rsx{vuxgokkGWRkQk[VUA]AQRk iXSDQk^Y[_N[ RUXGQO>FQ@AFZ>I>DSSNFNF[ABR	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZ>\BRZQB L]Y	PQR]ZQPYLW ^L@N cdkdxas}zkp}f>>ZQ_ENY@_MGQLR	UFFUM>\BRZQB L]YNWCUNEM >\BRZQB L]YU_GSMD@V >\BRZQB L]YXSDQk^Y[_N[  >>VGURBLBEQSF	>R[FQUW\ZQ_ENY@_MGQLRUG@WS\XZ[QkO>]R@WS\XZ[Qk		tsx{vuxgokkGWRk@Y@R NPPDCC@ki@WS\XZ[Qktsx{vuxgokkGWRkRGGEPZCXk i@WS\XZ[QkO>VGURBLBEQSF	@WS\XZ[Qk>>>>VFQU_>I>I>>>>]RVGURBLBEQSF			O>FQ@AFZ>I>>>B_[R\_CkPL	sx{vuxgokkGWRkWLGRkXNMY[kiVGURBLBEQSF>>>GDXkUA@[X[UPkFQS]G@QFRAZW@][Z\@WPS\LUZAGQB_[R\_CkPLO>R[FQUW\UFFUMB_[R\_CkPL\@WPS\LUZYLW ^L@N  B_[R\_CkPL\@WPS\LUZYLW ^L@NUGPkWRXLPM QFQDO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiPkWRXLPM QFQDO>]ZWXAPQk[ZWQPkWRXLPM QFQD>FQ@AFZ>I>I>I>Y@Z[D[X	tsx{vuxgokkGWRkBYEVDGkUNk iVGURBLBEQSF>]RY@Z[D[X			RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiY@Z[D[XXSDQk^Y[_N[  			RUXGQO>FQ@AFZ>I>Y@Z[D[X	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXU Y@Z[D[X>Y@Z[D[X	sx{vuxgokkGWRkR_]RRR^ ESkiNWCUNEM C[Q BXU Y@Z[D[X>]QD^DFXF V	YZM]DQZ RCCYZAS_QRWZAY QNWCUNEM >]R]QD^DFXF V			RUXGQO>FQ@AFZ>I>tsx{vuxgokkGWRk_GUYNZVVVk i]QD^DFXF VNWCUNEM Y@Z[D[X>@FMO>t]ZWXAPQ]QD^DFXF V>>>IR]ZUXXMO>UC[WM Z ]QD^DFXF V>I>GGEU[SFBALSP	sx{vuxgokkGWRk[\CPGL _]GZkiDSSNFNF[ABRdu`|}zr{kr}xqzuyq>>sx{vuxgoU_GSMD@Vi	DSSNFNF[ABR>sx{vuxgoXSDQk^Y[_N[ i	GGEU[SFBALSP>@]]\GEWLNV	U_GSMD@V>NWCUNEM>XSDQk^Y[_N[  >>U_GSMD@V>C[Q BXU>I>RS^]Q]]ZB@[U>I>I>CS@ @_RSQQRD	YZM]DQZ RCCYZAS_QRWZAY QNWCUNEM>]RCS@ @_RSQQRDO>tsx{vuxgokkGWRk_GUYNZVVVk iCS@ @_RSQQRD@]]\GEWLNV>@FMO>t]ZWXAPQCS@ @_RSQQRD>IR]ZUXXMO>UC[WM Z CS@ @_RSQQRD>>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>>>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>>>>RAZW@][ZA]G@N [QVkP_DZRB@WFAF\]LZZXW>>O>>>]Rsx{vuxgokkGWRkWBSB\_k i_DZRB@WFO>FQ@AFZ_DZRB@WF>I>>>UP_MB^MA[@EF	UFFUMYLW ^L@NU_GSMD@VU_GSMD@VXSDQk^Y[_N[  XSDQk^Y[_N[ >R[FQUW\UP_MB^MA[@EFUG_QMO>]R]GGQ@_DZRB@WFo_QMiHHsx{vuxgokkGWRkWBSB\_k i_DZRB@WFo_QMiO>W[Z@]ZAQ>I>\MkR ADAkL[S	UFFUM>>>>R[FQUW\_DZRB@WFo_QMiUGLWRBBEkLSO>>>]Rsx{vuxgokkGWRkWBSB\_k iLWRBBEkLSO>>>>\MkR ADAkL[Soi	LWRBBEkLS>W[Z@]ZAQ>I>_RE^PELQP	]GGQ@LWRBBEkLSoXSDQk^Y[_N[  iLWRBBEkLSoXSDQk^Y[_N[  i>GGEU[SFBALSP	]GGQ@sx{vuxgoYLW ^L@Nisx{vuxgoRS^]Q]]ZB@[Ui>]R_RE^PELQP			AF\]LZZXWHHGGEU[SFBALSP		_RE^PELQP			GGEU[SFBALSPO>W[Z@]ZAQ>I>\MkR ADAkL[Soi	A]G@N [QVkPLWRBBEkLSAF\]LZZXW>I>>_DZRB@WFo_QMi	\MkR ADAkL[S>I>FQ@AFZ_DZRB@WF>>>I>>>>I>RAZW@][ZLA]_R\MNS\]PF>O>]RQYD@Msx{vuxgoU_GSMD@ViFQ@AFZRUXGQ>sx{vuxgoRS^]Q]]ZB@[Ui	>FQ@AFZ@FAQ>I>>RAZW@][ZUGLQX @SCLAG>O>@FMO>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM SQ@k@FUZG]QZ@U_GSMD@V O>FQ@AFZ>I>]RLA]_R\MNS\]PFFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VGQ@k@FUZG]QZ@XSDQk^Y[_N[ >ZFDFkDQ	tsx{vuxgokkGWRkDNNU_UYWXVVkiR^N]SFX^UDZ^SGFZ>]RZFDFkDQZFDFkDQ
 ZFDFkDQLQQVQLQWV@  NBWM[ML[CR^N]SFX^UDZ^SGFZO>XDC[WBAQD	tsx{vuxgokkGWRkUMX_NCYCkiR^N]SFX^UDZ^SGFZ>AYZ]RZWU_ADX	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iAYZ]RZWU_ADXM[YQk NNVYMFB\AYZ]RZWU_ADXD^\[ GECU_NDSQ]_FXAYZ]RZWU_ADX			XCDS]V]N]\U[DX CO>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtWXQUFG@U@WUW\Q@FAQR^N]SFX^UDZ^SGFZ>>]Rtsx{vuxgokkGWRkUMX_NCYCkiR^N]SFX^UDZ^SGFZ			XDC[WBAQDtsx{vuxgokkGWRkDNNU_UYWXVVkiR^N]SFX^UDZ^SGFZ			ZFDFkDQO>>>>]R^EQW_ZP\[\_^S^R^N]SFX^UDZ^SGFZMV\Yk_]LXPMAYZ]RZWU_ADXO>>>CUB_YSQVGGNP[_BR^N]SFX^UDZ^SGFZ>RkV [kV DU^_R^N]SFX^UDZ^SGFZ>I>I>I>AZGQ@AYZ]RZWU_ADXXDC[WBAQD>I>[kBASMZMLV	tsx{vuxgokkGWRkDNNU_UYWXVVkiR^N]SFX^UDZ^SGFZ>NZLUVGU	[kBASMZMLV[kBASMZMLV
 >]RNZLUVGU[kBASMZMLV
 O>NZLUVGU	RUXGQ>I>]RNZLUVGU[kBASMZMLV
  ^RSDR NMZ]@D[kBASMZMLVO>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>GQ@k@FUZG]QZ@NWCUNEM >I>FQ@AFZ>I>]RNZLUVGUO>PURVLVUL	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iPURVLVULHHM[YQk NNVYMFB\PURVLVULO>NZLUVGU	RUXGQ>IQXGQO>>>>D @D[N@A^kB	M_E@QREC][RS^]Q]]ZB@[U>CBSBMX_BM	D^\[ GECU_NDSQ]_FXPURVLVUL>>>>AFGPPYNP 	D^\[ GECU_NDSQ]_FXsx{vuxgokkGWRkCGC  VMVVk iD @D[N@A^kBD @D[N@A^kB>]RCBSBMX_BM		AFGPPYNP 			HHBQFG][ZkW[YDUFQAFGPPYNP CBSBMX_BMO>MMDFGBA	sx{vuxgokkGWRkk[AFM@ZWUECkiPURVLVUL>>>>VP]WYFUW 	tsx{vuxgokkGWRk@Y@R NPPDCC@kisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U MMDFGBA>]RVP]WYFUW O>@WLWD\YQ	SQ@k[D@][ZYLW ^L@N>]Rsx{vuxgokkGWRkCGC  VMVVk i@WLWD\YQsx{vuxgokkGWRkUAU[DUV]kWki@WLWD\YQMMDFGBAH			VP]WYFUW 	@FAQ>I>]RVP]WYFUW NZLUVGU	RUXGQ>]RVP]WYFUW sx{vuxgokkGWRkCGC  VMVVk iD @D[N@A^kBD @D[N@A^kB			HHAFGPPYNP 			HHBQFG][ZkW[YDUFQAFGPPYNP CBSBMX_BMYSWP_GN@FXXXSDQk^Y[_N[ PURVLVULRS^]Q]]ZB@[U>AZGQ@MMDFGBAVP]WYFUW @WLWD\YQ>IQXGQ]Rsx{vuxgokkGWRkCGC  VMVVk iD @D[N@A^kBsx{vuxgokkGWRkD@WYYENNCMMkkiD @D[N@A^kB
 sx{vuxgokkGWRkD@WYYENNCMMkkiD @D[N@A^kB	 XABG]WV@AL\D @D[N@A^kBM[YQk NNVYMFB\D @D[N@A^kBsx{vuxgokkGWRkk[AFM@ZWUECkiPURVLVUL		sx{vuxgokkGWRkk[AFM@ZWUECkiD @D[N@A^kBO>NZLUVGU	RUXGQ>I>I>I>>>>]RNZLUVGUO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>GQ@k@FUZG]QZ@YLW ^L@N >I>FQ@AFZ>I>>>]RV@  NBWM[ML[CR^N]SFX^UDZ^SGFZO>FQ@AFZ>I>M k]^BMYQ@N 	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZ>]Rtsx{vuxgokkGWRkY  PFNk iM k]^BMYQ@N O>GEWVN@XUE@ P\\ZM k]^BMYQ@N  @FAQ>>>>I>CNCBkERLP\EF@	M_E@QREC][C[Q BXU>]RCNCBkERLP\EF@HHsx{vuxgokkGWRkCGC  VMVVk iCNCBkERLP\EF@O>]RSQ@k@FUZG]QZ@XSDQk^Y[_N[ O>[]\CNNBEZB[Q\APGU_GSMD@VNWCUNEM>GQ@k@FUZG]QZ@RS^]Q]]ZB@[U>I>>>>I>>>>]RCNCBkERLP\EF@sx{vuxgokkGWRkCGC  VMVVk iCNCBkERLP\EF@sx{vuxgokkGWRkD@WYYENNCMMkkiCNCBkERLP\EF@
LWLsx{vuxgokkGWRkD@WYYENNCMMkkiCNCBkERLP\EF@	   XABG]WV@AL\CNCBkERLP\EF@M[YQk NNVYMFB\CNCBkERLP\EF@O>X]]DXP^DkGP	D^\[ GECU_NDSQ]_FXCNCBkERLP\EF@>]RX]]DXP^DkGP			HHBQFG][ZkW[YDUFQX]]DXP^DkGPXCDS]V]N]\U[DX CO>FQ@AFZ>>I>L\GFD[MEU^ D	sx{vuxgokkGWRkk[AFM@ZWUECkiCNCBkERLP\EF@>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U L\GFD[MEU^ DFQ@AFZ>\V@XRF_GE	SQ@k[D@][ZU_GSMD@V >]Rsx{vuxgokkGWRkCGC  VMVVk i\V@XRF_GEsx{vuxgokkGWRkUAU[DUV]kWki\V@XRF_GEL\GFD[MEU^ DH			FQ@AFZ>AZGQ@L\GFD[MEU^ D\V@XRF_GE>DEFWAVkk@G	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZNWCUNEM>VQFMB\VLM	tsx{vuxgokkGWRk@Y@R NPPDCC@kiDEFWAVkk@Gsx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iDEFWAVkk@G>]RVQFMB\VLM		sx{vuxgokkGWRkk[AFM@ZWUECkiCNCBkERLP\EF@			VQFMB\VLMO>FQ@AFZ>I>>SUB\XXALLBWR W\F XR^N]SFX^UDZ^SGFZLWL>>>>WDBWRGU [M	^EQW_ZP\[\_^S^R^N]SFX^UDZ^SGFZMV\Yk_]LXPMCNCBkERLP\EF@>]RWDBWRGU [MO>CUB_YSQVGGNP[_BR^N]SFX^UDZ^SGFZ>SUB\XXALLBWR W\F XR^N]SFX^UDZ^SGFZ>RkV [kV DU^_R^N]SFX^UDZ^SGFZ>Z@SSV]@AXS]ZZY@FAQ>WU^YMASDXk_GG@FAQ>[URLARkUQG\YPR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>>GQ@k@FUZG]QZ@U_GSMD@V>I>IQXGQ]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>>>>GQ@k@FUZG]QZ@NWCUNEM>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>>I>>RAZW@][Z[ _MFYCEMFRWY@[\\>O>_GPVPERFUC@RL[RXSDQk^Y[_N[ U_GSMD@V>_GPVPERFUC@RL[RRS^]Q]]ZB@[UXSDQk^Y[_N[ >]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>FQY[BQkUW@][ZC[Q BXU NWCUNEM>FQY[BQkUW@][ZNWCUNEMRS^]Q]]ZB@[U  >FQY[BQkUW@][ZU_GSMD@VYLW ^L@N>>>I>>I>RAZW@][Z^kRNV^ZkB]X\>O>>>@FMO>CDPV	sx{vuxgoNWCUNEMi>>>\Q kB[LL_	CDPV
DFQR]LYLW ^L@N>>>>@YRWFGQ_QR^^] 	gXSDQk^Y[_N[ CDPV
AGQFGU_GSMD@VCDPV
AGQFYQ@UNWCUNEM >CB\FU]D^^	CDPV
SQ@kFQGAX@GCDPV
DFQDUFQ@YRWFGQ_QR^^] \Q kB[LL_RS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkWBSB\_k iCB\FU]D^^O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ G@F]ZSCDPV
XUG@kQFF[F>>>>FQ@AFZUFFUM>I>FQ@AFZCB\FU]D^^>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>I>>>>FQ@AFZUFFUM>>>>I>RAZW@][ZR]BB@CWC XMBAU@kFASBU>O>XXk^[U	UFFUM>NEUG_BS[Y^\	RAZW@][ZASZV\NZ@LO>ASZV\NZ@LoRS^]Q]]ZB@[Ui	>FQ@AFZASZV\NZ@L>I>@FMO>DSNFMRB^[	M_E@QREC][XSDQk^Y[_N[ UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iDSNFMRB^[DSNFMRB^[	UFFUM>kDP	RUXGQ>>>R[FQUW\DSNFMRB^[UG[MXPSBWE[	
BFNDPEPQE[FO>>>]Rsx{vuxgokkGWRkWBSB\_k iBFNDPEPQE[F]GGQ@BFNDPEPQE[FoWiBFNDPEPQE[FoQisx{vuxgokkGWRkWBSB\_k iBFNDPEPQE[FoWi]Z@BFNDPEPQE[FoQi
sx{vuxgokkGWRkNWYM^SkLZ[BNkiO>XXk^[Uo[MXPSBWE[i	BFNDPEPQE[FoWi>>>>IQXGQO>>>>AZGQ@DSNFMRB^[o[MXPSBWE[i>kDP	@FAQ>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHsx{vuxgokkGWRkQk[VUA]AQRk iC[Q BXUO>]RkDPYSWP_GN@FXXXSDQk^Y[_N[ DSNFMRB^[RS^]Q]]ZB@[U>FQ@AFZXXk^[U>>>>I>]Rsx{vuxgokkGWRkWBSB\_k iBAU@kFASBUHHQYD@MBAU@kFASBUO>]RkDPYSWP_GN@FXXRS^]Q]]ZB@[UDSNFMRB^[C[Q BXU>FQ@AFZXXk^[U>>I>L[V DG W	sx{vuxgokkGWRkNWYM^SkLZ[BNki    >]GkGGX	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N ]GkGGX>WLBYCEFB@F	]GkGGXXSDQk^Y[_N[ NWCUNEM >@FCZBVEY][A@S	]GkGGXPQR]ZQPYLW ^L@Ngqwafqkua`|kw{{}qPQR]ZQPNWCUNEMua`|kw{{}q>PEN_UV	PQR]ZQPYLW ^L@Nx{ssqpk}zkw{{}q>]R@FCZBVEY][A@SHHPEN_UVO>]RkDPYSWP_GN@FXXU_GSMD@VDSNFMRB^[YLW ^L@N>FQ@AFZXXk^[U>>>>I>ZUD@YSVFBBF	PQR]ZQPXSDQk^Y[_N[ w{{}qkp{yu}zsx{vuxgokkGWRkBL_FA]]]WPkiw{{}qkp{yu}z]]Ak[ZG\^^RAP]UMA>[AAZDFBSMkP	PQR]ZQPU_GSMD@Vw{{}qdu`|>ZS_LFMXBXV^ Q	PQR]ZQPRS^]Q]]ZB@[Uupy}zkw{{}qkdu`|C[Q BXU>ZU\LDWF^	]GkGGXYLW ^L@NNWCUNEM >[C[ALERkB	h@>>>>_GPVPERFUC@RL[RU_GSMD@VNEUG_BS[Y^\>DBUBAZPkAN	FLQWZ ED P NWCUNEM>SDMWAZWZ	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtSQ@k[D@][ZDBUBAZPkANUFFUMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iSDMWAZWZSDMWAZWZ	UFFUM>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>ASPZZQDLXV	]Z@tSQ@k[D@][ZFLQWZ ED P RS^]Q]]ZB@[U>]RASPZZQDLXVO>]RQYD@MSDMWAZWZO>SDMWAZWZ	UFFUM>tADPU@Qk[D@][ZDBUBAZPkANSDMWAZWZYLW ^L@N>I>tADPU@Qk[D@][ZFLQWZ ED P YLW ^L@NYLW ^L@N>>I>>>>AZGQ@ASPZZQDLXV>I>D@BBUVVBZ[	sx{vuxgokkGWRkEMVLY\AkiXXk^[U>>R[FQUW\BAU@kFASBUUG][BV\SO>]Rsx{vuxgokkGWRk@L\SQY@ZAki][BV\SHH][BV\S
}pHH][BV\S
AGQFkX[S]ZO>W[Z@]ZAQ>I>]RD@BBUVVBZ[
	O>>VFQU_>I>GDR^XP[_L	G@F]ZS][BV\S
AGQFkX[S]Z>>>]R]GGQ@XXk^[UoGDR^XP[_LiO>W[Z@]ZAQ>>>I>]R]GGQ@SDMWAZWZoGDR^XP[_Li]Z@SDMWAZWZoGDR^XP[_Li
sx{vuxgokkGWRkNWYM^SkLZ[BNki  O>W[Z@]ZAQ>>>>I>CDkWUW\QkPQXQ@Q][BV\S
}pYLW ^L@N>_AUF]N UC^k	SQ@kAGQFkYQ@U][BV\S
}pRS^]Q]]ZB@[U@FAQ>>>>]Rsx{vuxgokkGWRkWBSB\_k i_AUF]N UC^ksx{vuxgokkGWRkEMVLY\Aki_AUF]N UC^k
	 O>PABBML]	UFFUM>R[FQUW\_AUF]N UC^kUGVAWDB	
D\PUGLDR O>]R]GGQ@D\PUGLDR oYLW ^L@NiD\PUGLDR oYLW ^L@Ni
sx{vuxgokkGWRkNWYM^SkLZ[BNkiO>PABBML]oVAWDBi	D\PUGLDR >I>I>>>]Rsx{vuxgokkGWRkEMVLY\AkiPABBML]		sx{vuxgokkGWRkEMVLY\Aki_AUF]N UC^kO>ADPU@QkAGQFkYQ@U][BV\S
}pRS^]Q]]ZB@[UPABBML]>I>>I>CDkWUW\QkPQXQ@Q][BV\S
}pU_GSMD@V>WM][S^_LEPW	sx{vuxgokkGWRk_[B\CCNMkiUFFUMU_GSMD@VYLW ^L@N][BV\S
}p>Q_^[[[[LEFP	WM][S^_LEPW
WFQU@QL[V DG W>>XRYC\YV	UFFUM>XRYC\YVoi	ZUD@YSVFBBF[C[ALERkBRS^]Q]]ZB@[U[C[ALERkB[AAZDFBSMkP[C[ALERkBZU\LDWF^[C[ALERkBL[V DG W[C[ALERkBPEN_UV[C[ALERkBsx{vuxgokkGWRkWF[ZZ^\\k@k i][BV\S
}pL[V DG WC[Q BXUQ_^[[[[LEFP>]R@FCZBVEY][A@SO>XRYC\YVoi	ZUD@YSVFBBF[C[ALERkBYLW ^L@N[C[ALERkBZS_LFMXBXV^ Q[C[ALERkBZU\LDWF^[C[ALERkBL[V DG W[C[ALERkB@FCZBVEY][A@S[C[ALERkBsx{vuxgokkGWRkWF[ZZ^\\k@k i][BV\S
}pL[V DG WWLBYCEFB@FQ_^[[[[LEFP>I>XXk^[Uo][BV\S
AGQFkX[S]Zi	XRYC\YV>DSNFMRB^[oGDR^XP[_Li	UFFUMW	
XRYC\YVQ	
L[V DG W>kDP	@FAQ>D@BBUVVBZ[>I>]RkDPO>YSWP_GN@FXXU_GSMD@VDSNFMRB^[U_GSMD@V>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>[]\CNNBEZB[Q\APGC[Q BXU[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>I>FQY[BQkR]X@QFXSDQk^Y[_N[ NEUG_BS[Y^\>FQ@AFZXXk^[U>I>RAZW@][ZGXZLM@GDP>O>@FMO>DSNFMRB^[	M_E@QREC][XSDQk^Y[_N[ UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iDSNFMRB^[HHQYD@MDSNFMRB^[FQ@AFZ>DBUBAZPkAN	FLQWZ ED P NWCUNEM>SDMWAZWZ	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtSQ@k[D@][ZDBUBAZPkANUFFUMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iSDMWAZWZSDMWAZWZ	UFFUM>>R[FQUW\DSNFMRB^[UG[MXPSBWE[	
BFNDPEPQE[FO>>SDMWAZWZo[MXPSBWE[i	sx{vuxgokkGWRkWBSB\_k iBFNDPEPQE[F]GGQ@BFNDPEPQE[FoQi]Z@BFNDPEPQE[FoQisx{vuxgokkGWRkNWYM^SkLZ[BNki   >I>R[FQUW\SDMWAZWZUGZW^BkDEZ^DW	
G_FBN\EZ[UO>]R]Z@G_FBN\EZ[Usx{vuxgokkGWRkNWYM^SkLZ[BNkiAZGQ@SDMWAZWZoZW^BkDEZ^DWi>I>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtADPU@Qk[D@][ZDBUBAZPkANSDMWAZWZNWCUNEM>YSWP_GN@FXXRS^]Q]]ZB@[UUFFUMU_GSMD@V>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGC[Q BXU[GD[EZLN>I>I>RAZW@][ZVU@L@ZQR]QCQGPF XFCLW]_>>>O>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iQGPF XFCLW]_FQ@AFZQGPF XFCLW]_>]Rsx{vuxgokkGWRkWBSB\_k iQGPF XFCLW]_]GGQ@QGPF XFCLW]_oDisx{vuxgokkGWRkCGC  VMVVk iQGPF XFCLW]_oDiFQ@AFZQGPF XFCLW]_oDi>FQ@AFZ>>I>>>RAZW@][ZSWRL^AS_XFMBAU@kFASBU>O>X]G@	UFFUM>N]G N]R^Zk[	G@F]ZSM_E@QREC][C[Q BXU>>CXVXZX[ ^Q[VD	G@F]ZSM_E@QREC][YLW ^L@N>]RN]G N]R^Zk[		CXVXZX[ ^Q[VD		O>X]G@oN]G N]R^Zk[i	CXVXZX[ ^Q[VD>I>[A^V]Ak^	M_E@QREC][RS^]Q]]ZB@[U UFFUM>]Rsx{vuxgokkGWRkWBSB\_k i[A^V]Ak^O>R[FQUW\[A^V]Ak^UG^M\X^MS\	
WU]XUL]^ O>LUkFX_AZZZFQ	VU@L@ZQR]QCWU]XUL]^ >]RLUkFX_AZZZFQ		X]G@oG@F]ZS^M\X^MS\i	LUkFX_AZZZFQ>I>I>FQ@AFZX]G@>I>RAZW@][ZC__S\Y@CQZDWVEGE^M\X^MS\WP@VR^]W_MLBkLVNW>O>@FMO>]Rsx{vuxgokkGWRk@L\SQY@ZAki^M\X^MS\HHsx{vuxgokkGWRkUU\RUWEQki^M\X^MS\XSDQk^Y[_N[ O>FQ@AFZ^M\X^MS\>I>]R^M\X^MS\
\UGkWUDYLW ^L@NO>>>FQ@AFZ^M\X^MS\>>>I>]Rsx{vuxgokkGWRkCGC  VMVVk i_MLBkLVNWHH_MLBkLVNWO>FQ@AFZ^M\X^MS\>I>[A^V]Ak^	M_E@QREC][YLW ^L@N UFFUM>]Rsx{vuxgokkGWRkWBSB\_k i[A^V]Ak^O>[A^V]Ak^	UFFUM>I>R[FQUW\[A^V]Ak^UG_ELRS]^C	
MFkYLAQVWkNkO>>>>GLL][\B[\	sx{vuxgokkGWRkWBSB\_k iMFkYLAQVWkNk]GGQ@MFkYLAQVWkNkoU_GSMD@V i]Z@MFkYLAQVWkNkoXSDQk^Y[_N[  i>]RGLL][\B[\GLL][\B[\sx{vuxgokkGWRkNWYM^SkLZ[BNkiAZGQ@[A^V]Ak^o_ELRS]^Ci>I>[A^V]Ak^o^M\X^MS\
AGQFkX[S]Zi	UFFUMD	
_MLBkLVNWNWCUNEM 	
sx{vuxgokkGWRkNWYM^SkLZ[BNkiXSDQk^Y[_N[  	
>YSWP_GN@FXXYLW ^L@N[A^V]Ak^NWCUNEM>>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>>>>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>I>FQ@AFZ^M\X^MS\>>>>I>RAZW@][ZD^EE]\kLUS CNAYD E\VD^M\X^MS\>O>>@FMO>>]Rsx{vuxgokkGWRkCGC  VMVVk iCNAYD E\VDHHCNAYD E\VD			FQ@AFZ>[A^V]Ak^	M_E@QREC][RS^]Q]]ZB@[UUFFUM>]Rsx{vuxgokkGWRkWBSB\_k i[A^V]Ak^HH]GGQ@[A^V]Ak^oCNAYD E\VDiFQ@AFZ>[GD[EZLN	[A^V]Ak^oCNAYD E\VDi>]Rsx{vuxgokkGWRkWBSB\_k i[GD[EZLNQYD@M[GD[EZLNoXSDQk^Y[_N[  iO>[A^V]Ak^oCNAYD E\VDioXSDQk^Y[_N[  i	>YSWP_GN@FXXXSDQk^Y[_N[ [A^V]Ak^YLW ^L@N>I>IWU@W\`\F[CUVXQQWVWGU]_V_PBO>[]\CNNBEZB[Q\APGYLW ^L@NQWVWGU]_V_PB>>>IWU@W\qLWQD@][ZQWVWGU]_V_PBO>[]\CNNBEZB[Q\APGU_GSMD@VQWVWGU]_V_PB>I>I>RAZW@][ZQ]WFQGL\kDVDBAU@kFASBU>O>>>>]Rsx{vuxgokkGWRkWBSB\_k iBAU@kFASBUO>>>>FQ@AFZRUXGQ>I>>>>UWk Z]CPLGD	QQ\E@[^PEBRYMZ^PV>R[FQUW\BAU@kFASBUUG][BV\SO>>R[FQUW\UWk Z]CPLGDUGA]XEXAB\]QO>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXUsx{vuxgokkGWRkFSCP[[U^kiA]XEXAB\]QRS^]Q]]ZB@[U ][BV\S
AGQFkX[S]ZO>>>>FQ@AFZ][BV\S>I>I>I>FQ@AFZRUXGQ>I>>RAZW@][ZSL@D ]FAVZSMkBG] GL_CWV>O>FQ@AFZsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiSMkBG] GL_CWV>>>I>>>RAZW@][ZQWkW^LS NNARL_CWV>O>FQ@AFZSL@D ]FAVZAZ]E]PG@F]ZSsx{vuxgokkGWRkLFUXCD_ k i@FAQL_CWV>I>>>>RAZW@][ZB^ ^ZQ[kRYEGQGZDCPZkSGSNUN>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZRUXGQ>>>>YFMPU^]MCN	SQ@k[D@][ZNWCUNEM UFFUM>>>]Rsx{vuxgokkGWRkWBSB\_k iYFMPU^]MCNFQ@AFZRUXGQ>CPF]\AUC	sx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUN>]RQYD@MYFMPU^]MCNoCPF]\AUCiFQ@AFZRUXGQ>>LUkFX_AZZZFQ	sx{vuxgokkGWRkPF]F GWR@ZkiHG@F]ZSYFMPU^]MCNoCPF]\AUCi>>QA@ SPNB\	]GGQ@LUkFX_AZZZFQoi]Z@LUkFX_AZZZFQoi>FQ@AFZQA@ SPNB\
sx{vuxgokkGWRkNWYM^SkLZ[BNkiQA@ SPNB\LLQQ>I>RAZW@][ZPVZQRWF[]CRCYGXNQEFADCPZkSGSNUN\\D^D^R SY^^>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VHHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UFQ@AFZ>YFMPU^]MCN	SQ@k[D@][ZRS^]Q]]ZB@[U UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iYFMPU^]MCNYFMPU^]MCN	UFFUM>>CPF]\AUC	sx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUN>]R\\D^D^R SY^^O>>>]R]GGQ@YFMPU^]MCNoCPF]\AUCiO>AZGQ@YFMPU^]MCNoCPF]\AUCi>ADPU@Qk[D@][ZXSDQk^Y[_N[  YFMPU^]MCNC[Q BXU>>>>I>FQ@AFZ>I>>>ZFR GB^_Z	>]RQYD@MYFMPU^]MCNoCPF]\AUCiO>LUkFX_AZZZFQ	sx{vuxgokkGWRkPF]F GWR@ZkiHG@F]ZSYFMPU^]MCNoCPF]\AUCi>>ZFR GB^_Z	]Z@LUkFX_AZZZFQoi>I>ZFR GB^_Z>QA@ SPNB\	ZFR GB^_Z
	jsx{vuxgokkGWRkNWYM^SkLZ[BNki>R[FQUW\YFMPU^]MCNUG[@DRNS\^	
FY[FSVZW@k^V^FO>kC^DZDW	sx{vuxgokkGWRkPF]F GWR@ZkiHG@F]ZSFY[FSVZW@k^V^F>UAUC  k	]GGQ@kC^DZDWoi]Z@kC^DZDWoi>]RUAUC  kQYD@MkC^DZDWoiUAUC  k	]Z@kC^DZDWoi>>>>]RUAUC  ksx{vuxgokkGWRkNWYM^SkLZ[BNkiUAUC  k
AZGQ@YFMPU^]MCNo[@DRNS\^i>I>YFMPU^]MCNoCPF]\AUCi	ZFR GB^_ZHQA@ SPNB\Hsx{vuxgokkGWRkNWYM^SkLZ[BNki>>>]Rsx{vuxgokkGWRkEMVLY\AkiYFMPU^]MCN
 O>^VZEVQk\	UFFUM>R[FQUW\YFMPU^]MCNUG[@DRNS\^	
FY[FSVZW@k^V^FO>kC^DZDW	sx{vuxgokkGWRkPF]F GWR@ZkiHG@F]ZSFY[FSVZW@k^V^F>^VZEVQk\o[@DRNS\^i	]GGQ@kC^DZDWoi]Z@kC^DZDWoi]GGQ@kC^DZDWoi]Z@kC^DZDWoi>I>sx{vuxgokkGWRkEXDMPPGZk i^VZEVQk\>D[RF\@[P	sx{vuxgokkGWRkEMVLY\AkiYFMPU^]MCN>R[FQUW\^VZEVQk\UG[@DRNS\^	
LBQV\AYGUkGO>>]RD[RF\@[P	VFQU_>>>]R[@DRNS\^			CPF]\AUCW[Z@]ZAQ>AZGQ@YFMPU^]MCNo[@DRNS\^i>>>>D[RF\@[P>>I>AZGQ@^VZEVQk\LBQV\AYGUkGD[RF\@[P>>>>I>>ADPU@Qk[D@][ZNWCUNEM  YFMPU^]MCNU_GSMD@V >>>>I>RAZW@][ZG]G@[UXMBC_WRDCPZkSGSNUN@E^LP_[^V^ELL	ZAXX>O>]Rsx{vuxgokkGWRkCGC  VMVVk i@E^LP_[^FQ@AFZ>AZPG@LLQk\	YZM]DQZ RCCYZAsx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUNU_GSMD@V >>>]RAZPG@LLQk\		RUXGQO>]RV^ELL		ZAXXtsx{vuxgokkGWRkWWGZMMY]kRW^kiAZPG@LLQk\V^ELL  >]Rtsx{vuxgokkGWRk_GUYNZVVVk iAZPG@LLQk\@E^LP_[^			sx{vuxgokkGWRkD@WYYENNCMMkki@E^LP_[^]]EN_BYRS]UBkAZPG@LLQk\DCPZkSGSNUNFQ@AFZ>UC[WM Z AZPG@LLQk\>I>tsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUN@E^LP_[^>I>RAZW@][Z^EQW_ZP\[\_^S^DCPZkSGSNUNAX\PUMENN\>O>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[  U_GSMD@V sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>I>LGCZCRNS^	sx{vuxgokkGWRkQDZV_kiDCPZkSGSNUN			U_GSMD@V >]RLGCZCRNS^M[YQk NNVYMFB\AX\PUMENN\O>[]\CNNBEZB[Q\APGU_GSMD@VRS^]Q]]ZB@[Usx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>>>FQ@AFZRUXGQ>>>I>]RLGCZCRNS^B^ ^ZQ[kRYEGQGZDCPZkSGSNUNFQ@AFZRUXGQ>[GQR@SGX_S	RUXGQ>]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iDCPZkSGSNUN[GQR@SGX_S	@FAQ>@E^LP_[^	ZAXX>MSUBER	RUXGQ>>>UVQQMZ_FXN	ZAXX>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>MSUBER	@FAQ>]R[GQR@SGX_SO>UVQQMZ_FXN	tR]XQDQFYGDCPZkSGSNUN>]RUVQQMZ_FXN			RUXGQUVQQMZ_FXN	ZAXX>I>^AN@]@^\	tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN>]R^AN@]@^\		RUXGQ^AN@]@^\	 ^AN@]@^\	  HH^RSDR NMZ]@D^AN@]@^\@E^LP_[^	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>AZGQ@^AN@]@^\>>>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>[]\CNNBEZB[Q\APGC[Q BXUXSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>>>>I>]WNG_^[VRQN	RUXGQ>WG_RQ]YSWU	RUXGQ>>>kWX	sx{vuxgokkGWRkD@WYYENNCMMkkiAX\PUMENN\>R[FLL[CX\NYGVZQL	LL[CX\NYGVZQLLL[CX\NYGVZQLO>]WNG_^[VRQN	YZM]DQZ RCCYZAPLDRFkX ]D]@Y]U_GSMD@V>]R]WNG_^[VRQN		RUXGQO>WG_RQ]YSWU	RUXGQ>kC^DZDW	tsx{vuxgokkGWRkS\CU__XX EZki]WNG_^[VRQNC[Q BXU>>>>]RkC^DZDW		RUXGQO>DBRCLZ\E_A 	>C\]XQDBRCLZ\E_A kWXO>SSCXSG@ZEDL	tsx{vuxgokkGWRkP XkAVkikC^DZDWsx{vuxgokkGWRkQDZV_kiAX\PUMENN\DBRCLZ\E_A >>>]RSSCXSG@ZEDL			RUXGQHHSSCXSG@ZEDL			VFQU_>DBRCLZ\E_A 	SSCXSG@ZEDL>I>tRRXAG\kC^DZDW>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tRGMZWkC^DZDW>tRWX[GQkC^DZDW>]RDBRCLZ\E_A 			kWXWG_RQ]YSWU	DBRCLZ\E_A >IQXGQO>WG_RQ]YSWU	tsx{vuxgokkGWRk_GUYNZVVVk i]WNG_^[VRQNAX\PUMENN\>I>]RWG_RQ]YSWU		RUXGQWG_RQ]YSWU			kWXVFQU_>>>UC[WM Z ]WNG_^[VRQN>>>>]WNG_^[VRQN	RUXGQ>>I>I>]R]WNG_^[VRQN			RUXGQO>[]\CNNBEZB[Q\APGYLW ^L@NC[Q BXUsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>>I>]RWG_RQ]YSWU			RUXGQHHWG_RQ]YSWU		kWXO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UU_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>UC[WM Z ]WNG_^[VRQN>FQ@AFZRUXGQ>I>]RUVQQMZ_FXN		ZAXXtsx{vuxgokkGWRkWWGZMMY]kRW^ki]WNG_^[VRQNUVQQMZ_FXN>]R[GQR@SGX_SO>>>kLYF@F R	tsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUNAX\PUMENN\>]RkLYF@F R			kWXO>UC[WM Z ]WNG_^[VRQN>>tWXQUFG@U@WUW\Q@FAQDCPZkSGSNUN>>>[URLARkUQG\YPDCPZkSGSNUN>]RLGCZCRNS^PVZQRWF[]CRCYGXNQEFADCPZkSGSNUNRUXGQ>FQ@AFZ@FAQ>I>]Rsx{vuxgokkGWRkCGC  VMVVk i@E^LP_[^tsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUN@E^LP_[^>UC[WM Z ]WNG_^[VRQN>[]\CNNBEZB[Q\APGC[Q BXUU_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>I>GZMEL[	]]EN_BYRS]UBk]WNG_^[VRQNDCPZkSGSNUN>]RGZMEL[MSUBER[GQR@SGX_SO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNSUB\XXALLBWR W\F XDCPZkSGSNUN>MLM^C^kGG	DCPZkSGSNUNYLW ^L@Nsx{vuxgokkGWRkLFUXCD_ k i>]R]]EN_BYRS]UBkDCPZkSGSNUNMLM^C^kGGO>GZMEL[	]]EN_BYRS]UBk]WNG_^[VRQNDCPZkSGSNUN>]RGZMEL[O>>UC[WM Z MLM^C^kGG>IQXGQO>>>>]R]]EN_BYRS]UBkMLM^C^kGGDCPZkSGSNUN\BY\PG_QP]VFSU[G_GMLM^C^kGGDCPZkSGSNUNO>>G]G@[UXMBC_WRDCPZkSGSNUN@E^LP_[^UVQQMZ_FXN>I>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>G]G@[UXMBC_WRDCPZkSGSNUN@E^LP_[^UVQQMZ_FXN>I>>I>I>>>I>]RGZMEL[[GQR@SGX_SLGCZCRNS^O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNSUB\XXALLBWR W\F XDCPZkSGSNUN>>]R\BY\PG_QP]VFSU[G_G]WNG_^[VRQNDCPZkSGSNUNO>GZMEL[	@FAQ>UC[WM Z ]WNG_^[VRQN>I>I>]RGZMEL[O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUN]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN		kWXO>CDV_Zk@Q	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>>>]Rsx{vuxgokkGWRkCGC  VMVVk iCDV_Zk@QHHsx{vuxgokkGWRkCGC  VMVVk i@E^LP_[^CDV_Zk@Q		@E^LP_[^O>]Rsx{vuxgokkGWRkCGC  VMVVk i@E^LP_[^G]G@[UXMBC_WRDCPZkSGSNUN@E^LP_[^UVQQMZ_FXN>QXGQ]RMSUBERUC[WM Z DCPZkSGSNUN>I>AZGQ@CDV_Zk@Q>I>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>G]G@[UXMBC_WRDCPZkSGSNUN@E^LP_[^UVQQMZ_FXN>I>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ YLW ^L@Nsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>UC[WM Z ]WNG_^[VRQN>FQ@AFZRUXGQ>I>tWXQUFG@U@WUW\Q@FAQDCPZkSGSNUN>SBG]MYC^^	RUXGQ>>>>]RkWX	L LRQVPO>RXSWL]CYF	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>>SBG]MYC^^	sx{vuxgokkGWRkCGC  VMVVk iRXSWL]CYFsx{vuxgokkGWRkD@WYYENNCMMkkiRXSWL]CYF			kWXsx{vuxgokkGWRkk[AFM@ZWUECkiRXSWL]CYF			sx{vuxgokkGWRkk[AFM@ZWUECkiAX\PUMENN\>IQXGQO>WC]_MM@\[	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUt\UG\kR]XQXSDQk^Y[_N[ DCPZkSGSNUNRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iWC]_MM@\[WC]_MM@\[		SBG]MYC^^	WC]_MM@\[			sx{vuxgokkGWRkk[AFM@ZWUECkiAX\PUMENN\>QXGQO>_Z[D]]M_QWkL	tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN>]R_Z[D]]M_QWkL			kWXO>VWBNPQX@_P^YUZ	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXXLWLRR>kF@	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXXkWX >SBG]MYC^^	sx{vuxgokkGWRkCGC  VMVVk iVWBNPQX@_P^YUZsx{vuxgokkGWRkCGC  VMVVk ikF@VWBNPQX@_P^YUZ			sx{vuxgokkGWRkQDZV_kiAX\PUMENN\ kF@			sx{vuxgokkGWRkQDZV_kiAX\PUMENN\kWX >I>I>I>]RSBG]MYC^^O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UNWCUNEM sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>]RLGCZCRNS^PVZQRWF[]CRCYGXNQEFADCPZkSGSNUN@FAQ>]Rsx{vuxgokkGWRkCGC  VMVVk i@E^LP_[^O>Dk_EGGA@AMMX	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Ut\UG\kR]XQC[Q BXUDCPZkSGSNUNRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iDk_EGGA@AMMXDk_EGGA@AMMX		Dk_EGGA@AMMX		sx{vuxgokkGWRkk[AFM@ZWUECkiAX\PUMENN\Dk_EGGA@AMMX		sx{vuxgokkGWRkk[AFM@ZWUECki@E^LP_[^O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ U_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>I>>>>^XMXF\WPZB	YZM]DQZ RCCYZAPLDRFkX ]D]@Y]C[Q BXU>]R^XMXF\WPZB		RUXGQtsx{vuxgokkGWRk_GUYNZVVVk i^XMXF\WPZB@E^LP_[^			sx{vuxgokkGWRkD@WYYENNCMMkki@E^LP_[^O>>>>tsx{vuxgokkGWRkWWGZMMY]kRW^ki^XMXF\WPZBUVQQMZ_FXN		ZAXXUVQQMZ_FXN >]R]]EN_BYRS]UBk^XMXF\WPZBDCPZkSGSNUNO>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUN[GQR@SGX_SSUB\XXALLBWR W\F XDCPZkSGSNUN>]R[GQR@SGX_S\BY\PG_QP]VFSU[G_G^XMXF\WPZBDCPZkSGSNUNO>UC[WM Z ^XMXF\WPZB>IQXGQO>tsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUN@E^LP_[^>UC[WM Z ^XMXF\WPZB>I>I>IQXGQO>]R^XMXF\WPZB		RUXGQUC[WM Z ^XMXF\WPZB>tsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUN@E^LP_[^>I>[URLARkUQG\YPDCPZkSGSNUN>IQXGQ]RMSUBERO>UC[WM Z DCPZkSGSNUN>I>FQ@AFZRUXGQ>I>>[URLARkUQG\YPDCPZkSGSNUN>CUB_YSQVGGNP[_BDCPZkSGSNUN>>SUB\XXALLBWR W\F XDCPZkSGSNUNUVQQMZ_FXN		ZAXXUVQQMZ_FXN >]RLGCZCRNS^PVZQRWF[]CRCYGXNQEFADCPZkSGSNUNRUXGQ>FQ@AFZ@FAQ>I>RAZW@][ZQNDFDLWZkF@@LXFADCPZkSGSNUNYDA@GLWN ]>O>>>>NENDELUZDQD^Z\B	D\DhZ>]Rsx{vuxgokkGWRkCGC  VMVVk iYDA@GLWN ]YDA@GLWN ]		sx{vuxgokkGWRkUAU[DUV]kWkiYDA@GLWN ]NWCUNEM 		RUXGQM[YQk NNVYMFB\YDA@GLWN ]NENDELUZDQD^Z\B	YDA@GLWN ]>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>>>kAkZXAR	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>>>]Rsx{vuxgokkGWRkCGC  VMVVk ikAkZXAR^UNF\NZMLZLZkN[XAkAkZXAR			NENDELUZDQD^Z\BFQ@AFZ>I>]R^EQW_ZP\[\_^S^DCPZkSGSNUNNENDELUZDQD^Z\BO>R[]USk QWAV	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>>>]Rsx{vuxgokkGWRkCGC  VMVVk iR[]USk QWAV^UNF\NZMLZLZkN[XAR[]USk QWAV			NENDELUZDQD^Z\Btsx{vuxgokkGWRk_GUYNZVVVk iDCPZkSGSNUNNENDELUZDQD^Z\B>AZGQ@R[]USk QWAV>I>[URLARkUQG\YPDCPZkSGSNUN>I>RAZW@][ZUR\S^_NU NZP\W]G>>>>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ VF]@EPQ[kN_MFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VCMM[CQBFBQRWkCLDWFE\	FQ@AFZ@FAQ>P\EZ R\GU	sx{vuxgokkGWRk]LMMNL  Gk isx{vuxgokkGWRkPYBC^AAPLk i ]Z@CMM[CQBFBQRWkCLDWFE\>>>@LDZEPEW[[	\[YQkAFX>@LDZEPEW[[	sx{vuxgokkGWRkUAU[DUV]kWki@LDZEPEW[[			RUXGQNWCUNEMsx{vuxgokkGWRkNWYM^SkLZ[BNkisx{vuxgokkGWRkLFUXCD_ k i>>>>ENG]k^WEkWXFG	sx{vuxgokkGWRkPX^@X\kki@FAQ>]MC[kQAAGC	sx{vuxgokkGWRkVkFMXL ki@LDZEPEW[[UFFUMNWCUNEM	
P\EZ R\GUYLW ^L@N	
RUXGQRS^]Q]]ZB@[U	
XSDQk^Y[_N[ 	
  RS^]Q]]ZB@[U	
UFFUMNWCUNEM 	
RS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ YLW[UL]YF^VN@Gsx{vuxgokkGWRkPX^@X\kki@FAQENG]k^WEkWXFG>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U]GkCDkQFF[F]MC[kQAAGCO>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UCMM[CQBFBQRWkCLDWFE\	FQ@AFZ@FAQ>P\EZ R\GU	sx{vuxgokkGWRk]LMMNL  Gk isx{vuxgokkGWRkPYBC^AAPLk iL L]Z@CMM[CQBFBQRWkCLDWFE\>ENG]k^WEkWXFG	sx{vuxgokkGWRkPX^@X\kki@FAQ>]MC[kQAAGC	sx{vuxgokkGWRkVkFMXL ki@LDZEPEW[[UFFUMNWCUNEM	
P\EZ R\GUXSDQk^Y[_N[ 	
RUXGQYLW ^L@N	
C[Q BXU	
  YLW ^L@N	
UFFUMYLW ^L@N 	
YLW ^L@N>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMYLW[UL]YF^VN@Gsx{vuxgokkGWRkPX^@X\kki@FAQENG]k^WEkWXFG>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU]GkCDkQFF[F]MC[kQAAGCFQ@AFZRUXGQ>>I>PBNAQZWL	]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQ]MC[kQAAGC>FQ@AFZPBNAQZWL
	L L PBNAQZWL  >I>RAZW@][ZXSZQYY@]R@[EG^@PS]k C_GLGVDW@C\WR\FA YA>O>@YRWFGQ_QR^^] 	sx{vuxgokkGWRkFSCP[[U^kisx{vuxgokkGWRkQANE SG_kXV\kiVDW@C\WR\FA YA>R[FQUW\>UFFUM>YLW ^L@N@YRWFGQ_QR^^] YLW ^L@N>YLW ^L@N @YRWFGQ_QR^^] XSDQk^Y[_N[ >RS^]Q]]ZB@[U@YRWFGQ_QR^^] RS^]Q]]ZB@[U>>>U_GSMD@V>RS^]Q]]ZB@[U>>UG^CXCGEBkAE>O>]Rsx{vuxgokkGWRkCGC  VMVVk iPS]k C_GLGVFQU_>PS]k C_GLG	sx{vuxgokkGWRkWBQASY @NZRk i^CXCGEBkAEhZPS]k C_GLG>I>FQ@AFZPS]k C_GLG>I>RAZW@][Z[URLARkUQG\YPZE[DCkFR]>O>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>]Rt[DWUW\Qk]ZBUX]PU@QZE[DCkFR]@FAQ		RUXGQFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZV[[Xt[DWUW\QkFQGQ@>>>>FQ@AFZRUXGQ>I>L[Pk[QSSGL	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vt[DWUW\QkSQ@kG@U@AGRUXGQRUXGQ>FQ@AFZsx{vuxgokkGWRkWBSB\_k iL[Pk[QSSGLQYD@ML[Pk[QSSGLoRS^]Q]]ZB@[Ui>I>RAZW@][Z_ W^\V CPNY_DCPZkSGSNUN_DZRB@WFUMSPCLPkY>>>O>]Rsx{vuxgokkGWRkQDZV_kiDCPZkSGSNUNj			U_GSMD@V O>]R^EQW_ZP\[\_^S^DCPZkSGSNUN_DZRB@WFO>[]\CNNBEZB[Q\APGUMSPCLPkYXSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>I>[URLARkUQG\YPDCPZkSGSNUN>FQ@AFZsx{vuxgokkGWRkD@WYYENNCMMkki_DZRB@WF>I>kC^DZDW	tsx{vuxgokkGWRkS\CU__XX EZkiDCPZkSGSNUNU_GSMD@V>]RkC^DZDW			RUXGQO>[]\CNNBEZB[Q\APGUMSPCLPkYU_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>FQ@AFZRUXGQ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM tRX[W_kC^DZDWx{wkql>]MC[kQAAGC	tsx{vuxgokkGWRkP XkAVkikC^DZDW_DZRB@WF>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM tRX[W_kC^DZDWx{wkaz>tRWX[GQkC^DZDW>]R]MC[kQAAGC			RUXGQHH_DZRB@WF		]MC[kQAAGC		sx{vuxgokkGWRkD@WYYENNCMMkki_DZRB@WFO>[]\CNNBEZB[Q\APGUMSPCLPkYRS^]Q]]ZB@[Usx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUN>>>FQ@AFZRUXGQ>I>FQ@AFZ]MC[kQAAGC>I>>>>>RAZW@][Z]][k]NUQWVX^VBDY>O>>>>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>@WRYSCWMRD]^PLZAXX>>>FQ@AFZ>I>]RSQ@k@FUZG]QZ@RS^]Q]]ZB@[UFQ@AFZ>]RSQ@k@FUZG]QZ@YLW ^L@NFQ@AFZ>GQ@k@FUZG]QZ@XSDQk^Y[_N[ >@WRYSCWMRD]^PLZAXX>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UPQXQ@Qk@FUZG]QZ@U_GSMD@V>N]G N]R^Zk[	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VG@F]ZSM_E@QREC][XSDQk^Y[_N[ >]RN]G N]R^Zk[		sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUAGQFZUYQkQL]G@GN]G N]R^Zk[O>GQ@k@FUZG]QZ@RS^]Q]]ZB@[U>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>>I>>I>>RAZW@][Z@WRYSCWMRD]^PLBAU@kFASBU>O>>]RPZEURB[UWFUPXSDQk^Y[_N[  FQ@AFZRUXGQ>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMHHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>FQ@AFZRUXGQ>I>WP@VR^]W	G@F]ZSM_E@QREC][XSDQk^Y[_N[ >]RWP@VR^]W		AGQFZUYQkQL]G@GWP@VR^]WG@F]ZSM_E@QREC][C[Q BXU		O>>>>FQ@AFZRUXGQ>I>>]RWP@VR^]W			O>N]CZ]]VSC	sx{vuxgokkGWRkWBSB\_k iBAU@kFASBUBAU@kFASBU^kRNV^ZkB]X\>@FkWVS	Q]WFQGL\kDVDN]CZ]]VSC>]R>@FkWVSQYD@M@FkWVS
AGQFkX[S]Z]GGQ@@FkWVS
AGQFkQYU]X>@FkWVS
AGQFkQYU]X			@FkWVS
AGQFkX[S]Zt]]Ak[ZG\^^RAP]UMAXSDQk^Y[_N[ >>O>WP@VR^]W	G@F]ZS@FkWVS
AGQFkX[S]Z>I>I>]RWP@VR^]W		AGQFZUYQkQL]G@GWP@VR^]WO>C@\ZSZNQD	AGQFZUYQkQL]G@GWP@VR^]W>_MLBkLVNW	QWkW^LS NNAR>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>>>>sx{vuxgokkGWRkNV@EDXNBQki_MLBkLVNWC@\ZSZNQD>I>>]RYSWP_GN@FXXRS^]Q]]ZB@[UWP@VR^]WU_GSMD@V YSWP_GN@FXXU_GSMD@VWP@VR^]WU_GSMD@V >]RYSWP_GN@FXXNWCUNEM_MLBkLVNWNWCUNEM YSWP_GN@FXXYLW ^L@N_MLBkLVNWU_GSMD@V >]RG@F]ZSM_E@QREC][NWCUNEM		WP@VR^]WHHG@F]ZSM_E@QREC][NWCUNEM		_MLBkLVNWO>[]\CNNBEZB[Q\APGU_GSMD@VRS^]Q]]ZB@[U>FQ@AFZRUXGQ>I>FQ@AFZ@FAQ>>>>I>UWk Z]CPLGD	QQ\E@[^PEBRYMZ^PV>]R@FAQO>WP@VR^]W	>>R[FFBLSQR FX	FBLSQR FXjFBLSQR FXO>LL[CX\NYGVZQL	UWk Z]CPLGDosx{vuxgokkGWRkQZYQLXF\kiUWk Z]CPLGDiQWkW^LS NNAR>]RAGQFZUYQkQL]G@GLL[CX\NYGVZQLO>>>>WP@VR^]W	LL[CX\NYGVZQL>VFQU_>I>>>>I>>>]RWP@VR^]W			O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UC[Q BXU>FQ@AFZRUXGQ>>>>I>>>>I>_MLBkLVNW	QWkW^LS NNAR >>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM PQR]ZQPC[Q BXUsx{vuxgokkGWRk\]XDEBSkWEkiuvgdu`|XSDQk^Y[_N[ O>FQEA]FQk[ZWQuvgdu`|NWCUNEM>>I>[_LUQ^Z	WP@VR^]Wt]]Ak[ZG\^^RAP]UMAU_GSMD@V>NZYYBNVB	RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>NZYYBNVB	sx{vuxgokkGWRk__DWLCWD Ck iUFFUM>NWCUNEM	
WP@VR^]W>YLW ^L@N	
_MLBkLVNW>>NWCUNEM	
[_LUQ^Z>>>>YLW ^L@N	
NWCUNEM>>XSDQk^Y[_N[ 	
WP@VR^]W>>]R]GkCDkQFF[FNZYYBNVBO>[]\CNNBEZB[Q\APGNWCUNEMNZYYBNVB
SQ@kQFF[FkW[PQNZYYBNVB
SQ@kQFF[FkYQGGUSQ>NZYYBNVB	RUXGQ>I>I>]RNZYYBNVBO>CDPV	]GGQ@sx{vuxgoXSDQk^Y[_N[ isx{vuxgoXSDQk^Y[_N[ iZAXX>]RCDPVHHsx{vuxgokkGWRk@L\SQY@ZAkiCDPVO>>>[]\CNNBEZB[Q\APGNWCUNEMU_GSMD@V>FQ@AFZRUXGQ>I>\AGCX_QQD	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N CDk\UG\kDUGGC[FP_MLBkLVNWsx{vuxgokkGWRkk[AFM@ZWUECki_MLBkLVNW>[PBCS@XBRQR	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUWAFFQZ@k@]YQYLW ^L@NSYPU@QRS^]Q]]ZB@[U>[G[[UQ PFXRBP	CDPV
]ZGQF@CDPV
AGQFGUFFUM>>XSDQk^Y[_N[ 	
WP@VR^]W>YLW ^L@N	
\AGCX_QQD>U_GSMD@V	
WP@VR^]W>YLW ^L@N	
[_LUQ^Z>RS^]Q]]ZB@[U	
[PBCS@XBRQR>NWCUNEM	
>YLW ^L@N	
WP@VR^]W>>>UFFUMYLW ^L@NNWCUNEMNWCUNEMYLW ^L@NU_GSMD@VRS^]Q]]ZB@[U XSDQk^Y[_N[ >>]R[G[[UQ PFXRBPO>[]\CNNBEZB[Q\APGU_GSMD@VRS^]Q]]ZB@[U>FQ@AFZRUXGQ>I>NZYYBNVB	]Z@CDPV
]ZGQF@k]P>\Q kB[LL_	CDPV
DFQR]LYLW ^L@N>CDPV
]ZGQF@CDPV
AGQFYQ@UUFFUM>NWCUNEM	
NZYYBNVB>NWCUNEM	
\Q kB[LL_>C[Q BXU 	
sx{vuxgokkGWRkS[G]P_P[ZkiUFFUMNWCUNEM	
@FAQ>>>UFFUMU_GSMD@V RS^]Q]]ZB@[URS^]Q]]ZB@[U>CDPV
]ZGQF@CDPV
AGQFYQ@UUFFUM>U_GSMD@V	
NZYYBNVB>RS^]Q]]ZB@[U	
CDPV
DFQR]LC[Q BXU >RS^]Q]]ZB@[U 	
>UFFUMNWCUNEM YLW ^L@NNWCUNEM>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V  O>WXQUZkAGQFkWUW\QNZYYBNVB>I>I>]RAGQFZUYQkQL]G@GWP@VR^]WO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UU_GSMD@V >>>>FQ@AFZRUXGQ>I>_ELRS]^C	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  SQ@kAGQFkVMRS^]Q]]ZB@[U WP@VR^]WRUXGQ>]U@AQQ]^_M	RUXGQ>>>]R_ELRS]^CQYD@M_ELRS]^C
}pO>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U O>>>>]U@AQQ]^_M	V[[XAGQFkWUZ_ELRS]^CU_GSMD@V>IQXGQ]R]GGQ@_ELRS]^C
WUDGsx{vuxgokkGWRkWBSB\_k i_ELRS]^C
WUDGO>]U@AQQ]^_M	QYD@M_ELRS]^C
WUDGoNWCUNEMi>I>I>]R]U@AQQ]^_MO>[]\CNNBEZB[Q\APGU_GSMD@VNWCUNEM >]RNZYYBNVBO>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UPQR]ZQPXSDQk^Y[_N[ tsx{vuxgokkGWRk\]XDEBSkWEkiuvgdu`|NWCUNEMO>FQEA]FQk[ZWQuvgdu`|NWCUNEM>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tCDkPQXQ@QkAGQFNZYYBNVB>I>FQ@AFZRUXGQ>I>]RYSWP_GN@FXXYLW ^L@NWP@VR^]WYLW ^L@N YSWP_GN@FXXYLW ^L@NWP@VR^]WXSDQk^Y[_N[ >]RYSWP_GN@FXXRS^]Q]]ZB@[U_MLBkLVNWXSDQk^Y[_N[ YSWP_GN@FXXRS^]Q]]ZB@[U_MLBkLVNWU_GSMD@V>>]RG@F]ZSM_E@QREC][XSDQk^Y[_N[ 		WP@VR^]WHHG@F]ZSM_E@QREC][XSDQk^Y[_N[ 		_MLBkLVNWO>[]\CNNBEZB[Q\APGU_GSMD@VXSDQk^Y[_N[ >>FQ@AFZRUXGQ>I>>>FQ@AFZ@FAQ>IWU@W\`\F[CUVXQ[GD[EZLNO>>>>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IR]ZUXXMO>>>>L^U[US^\kM^XSDQk^Y[_N[  >>>>I>>FQ@AFZRUXGQ>I>>>RAZW@][ZZZY\^XMY\R^NS>>>O>>>@FMO>>]Rsx{vuxgokkGWRk@L\SQY@ZAkiR^NSHHDF[DQF@MkQL]G@GR^NSRS^]Q]]ZB@[UO>FQ@AFZR^NS>I>>WP@VR^]W	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ G@F]ZSM_E@QREC][U_GSMD@V>]RWP@VR^]WO>FQ@AFZR^NS>I>>>>YQSXLFCVZW	QGWkGEXWP@VR^]W>]Rsx{vuxgokkGWRkUAU[DUV]kWkiR^NS
EAQFMkC\QFQYQSXLFCVZW			RUXGQO>R^NS
EAQFMkC\QFQ	NWCUNEMYQSXLFCVZW>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>FQ@AFZR^NS>I>RAZW@][ZC_[GX[LLDF\CVDLLEDF]>>>>O>@FMO>N]G N]R^Zk[	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU G@F]ZSM_E@QREC][U_GSMD@V>]RN]G N]R^Zk[O>FQ@AFZ\CVDLLEDF]>I>>>>NMQ@S [YEM	UFFUMC[Q BXURS^]Q]]ZB@[U>R[FQUW\NMQ@S [YEMUG_QMO>]R]GGQ@\CVDLLEDF]o_QMisx{vuxgokkGWRkCGC  VMVVk i\CVDLLEDF]o_QMisx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ \CVDLLEDF]o_QMiWCLB@]UGO>ZFR GB^_Z	sx{vuxgokkGWRk]LMMNL  Gk i]Z@WCLB@]UGoi>\CVDLLEDF]o_QMi	sx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@NZFR GB^_Z\CVDLLEDF]o_QMi>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>I>FQ@AFZ\CVDLLEDF]>I>RAZW@][ZAU^PQ YLEQNGS][DNUYAEkLDS\]]]XDZ]P\>>>O>@FMO>WP@VR^]W	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N G@F]ZSM_E@QREC][U_GSMD@V>]RWP@VR^]W			O>FQ@AFZS][DNUYAEkLDS\>I>]Rsx{vuxgokkGWRkWBSB\_k iS][DNUYAEkLDS\O>FQ@AFZS][DNUYAEkLDS\>I>]R]GGQ@S][DNUYAEkLDS\oRS^]Q]]ZB@[UiHHsx{vuxgokkGWRkWBSB\_k iS][DNUYAEkLDS\oYLW ^L@NiO>S][DNUYAEkLDS\oXSDQk^Y[_N[ i	UFFUM>I>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iWP@VR^]WS][DNUYAEkLDS\oNWCUNEMi@FAQO>S][DNUYAEkLDS\oU_GSMD@Vioi	WP@VR^]W>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>FQ@AFZS][DNUYAEkLDS\>I>>>RAZW@][ZQB\YZkNPD_NDN ^>O>ZEX_RLMUM C	UFFUM>>]RPQR]ZQPRS^]Q]]ZB@[Usx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>^]MFR[G 	UFFUMSQ@k[D@][ZYLW ^L@NUFFUM>_EDL V[Rk	UFFUM>R[FQUW\^]MFR[G UGVUGQZUYQO>>]Rsx{vuxgokkGWRkCGC  VMVVk iVUGQZUYQHHsx{vuxgokkGWRkUAU[DUV]kWkiVUGQZUYQU_GSMD@V  		RUXGQO>W[Z@]ZAQ>I>SLG]XSCCVA	sx{vuxgokkGWRkWLGRkXNMY[kiVUGQZUYQ>>>]RSLG]XSCCVA			O>SLG]XSCCVA	VUGQZUYQ>I>]R]GGQ@_EDL V[RkoSLG]XSCCVAiO>W[Z@]ZAQ>I>_EDL V[RkoSLG]XSCCVAi	@FAQ>DCPZkSGSNUN	cdkdxas}zkp}fVUGQZUYQ>]Rsx{vuxgokkGWRkWLGRkXNMY[kiVUGQZUYQ			O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNO>ZEX_RLMUM Coi	DCPZkSGSNUN>I>IQXGQO>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUN>>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]O>ZEX_RLMUM C	sx{vuxgokkGWRkPE\P] W]XPFFAkiZEX_RLMUM CEZ\GRD^GV@_kD\PPLDRFkX ]D]@Y]UFFUMU_GSMD@V >I>>I>I>I>>]Rtsx{vuxgokkGWRkY  PFNk iVZ[[SF]P]DGWUAZO>W^P@S^DPG	[FZWA_XLGNXRVZ[[SF]P]DGWUAZLWLW>]Rsx{vuxgokkGWRkWBSB\_k iW^P@S^DPGO>R[FQUW\W^P@S^DPGUGN@ S^VDL@QB O>]RN@ S^VDL@QB 			\ASSNCBDS[ZG^O>W[Z@]ZAQ>I>ZE[DCkFR]	VZ[[SF]P]DGWUAZN@ S^VDL@QB >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiZE[DCkFR]sx{vuxgokkGWRkX@FXkisx{vuxgokkGWRk[\CPGL _]GZkiN@ S^VDL@QB W[ZG@UZ@U_GSMD@V			C[Q BXU O>ZEX_RLMUM Coi	ZE[DCkFR]>>>>I>I>I>>>I>>]RPQR]ZQPC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>>>QY]VD\\QWZN	G@F]ZSSQ@k[D@][ZC[Q BXU>>>P_EFNRQMNB]ABEN	G@F]ZSSQ@k[D@][ZU_GSMD@V>ASMFX[^	PQR]ZQPYLW ^L@Ncdkw{z`qz`kp}fNWCUNEMuvgdu`|U_GSMD@V>ZSDk^WVBkE	sx{vuxgokkGWRk_SM[G_FkLFk isx{vuxgokkGWRk\QX@@RVGD kiUFFUMQY]VD\\QWZNP_EFNRQMNB]ABEN>R[FQUW\ZSDk^WVBkEUG[C[ALERkBO>]Rsx{vuxgokkGWRkUAU[DUV]kWki[C[ALERkBC[Q BXU  		RUXGQO>>>>W[Z@]ZAQ>I>>\BBU]]B	ASMFX[^[C[ALERkB>]Rtsx{vuxgokkGWRkY  PFNk i\BBU]]BO>>>LFPZBUP	[FZWA_XLGNXR\BBU]]B>]Rsx{vuxgokkGWRkWBSB\_k iLFPZBUPO>R[FQUW\LFPZBUPUGN@ S^VDL@QB O>]XFZSDM]	\BBU]]BN@ S^VDL@QB >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki]XFZSDM]sx{vuxgokkGWRkX@FXkisx{vuxgokkGWRk[\CPGL _]GZkiN@ S^VDL@QB W[ZG@UZ@C[Q BXU			NWCUNEM O>ZEX_RLMUM Coi	]XFZSDM]>I>I>>>I>>>>>GCN[DXXC	\BBU]]BNWCUNEM>]Rtsx{vuxgokkGWRkY  PFNk iGCN[DXXCO>ZEX_RLMUM C	sx{vuxgokkGWRkPE\P] W]XPFFAkiZEX_RLMUM CEZ\GRD^GV@_kD\PGCN[DXXCUFFUMU_GSMD@V>I>I>>I>I>FQ@AFZsx{vuxgokkGWRk_SM[G_FkLFk iZEX_RLMUM C>>I>>>>RAZW@][Z\F^A^\ YFUAMALM]]GFCCMEMBEZ_>O>]Rsx{vuxgokkGWRkWBSB\_k iGFCCMEMBEZ_FQ@AFZUFFUM>\MkR ADAkL[S	UFFUM>R[FQUW\GFCCMEMBEZ_UG]MC[kQAAGCO>]Rsx{vuxgokkGWRkCGC  VMVVk i]MC[kQAAGCHH]MC[kQAAGC			HHsx{vuxgokkGWRkD@WYYENNCMMkki]MC[kQAAGC
  W[Z@]ZAQ>@FMO>>>>]Rtsx{vuxgokkGWRkUQ Y]ZXWDki]MC[kQAAGC			RUXGQW[Z@]ZAQ>IWU@W\`\F[CUVXQ[GD[EZLNO>>W[Z@]ZAQ>IWU@W\qLWQD@][Z[GD[EZLNO>W[Z@]ZAQ>I>\MkR ADAkL[Soi	]MC[kQAAGC>>>I>FQ@AFZ\MkR ADAkL[S>I>>>RAZW@][ZCQZQM@LUDPCQGCWL]GFCCMEMBEZ_>O>@FMO>>]RQYD@MGFCCMEMBEZ_O>FQ@AFZRUXGQ>I>>ZEX_RLMUM C	QB\YZkNPD_NDN ^>>>>]RQYD@MZEX_RLMUM CO>FQ@AFZRUXGQ>I>Q_DZ^WGSVMM@D@	RUXGQ>R[FQUW\ZEX_RLMUM CUGZE[DCkFR]O>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiZE[DCkFR]HHtsx{vuxgokkGWRk_XXP] C^Mk iZE[DCkFR]O>>>W[Z@]ZAQ>I>>]Rtsx{vuxgokkGWRkDNNU_UYWXVVkiZE[DCkFR]
 O>>>W[Z@]ZAQ>I>>>AX\PUMENN\	tsx{vuxgokkGWRkBYEVDGkUNk iZE[DCkFR]>>>]RAX\PUMENN\HHsx{vuxgokkGWRkCGC  VMVVk iAX\PUMENN\O>W[Z@]ZAQ>>>>I>>>>>[F][EAG]YFADE	RUXGQ>R[FQUW\GFCCMEMBEZ_UGk_ Pk]B_LO>@FMO>>>ZGN CGF_SSWR@	tsx{vuxgokkGWRkWBQASY @NZRk ik_ Pk]B_LAX\PUMENN\>]RZGN CGF_SSWR@		ZAXXZGN CGF_SSWR@		AX\PUMENN\O>AX\PUMENN\	ZGN CGF_SSWR@>[F][EAG]YFADE	@FAQ>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>W[Z@]ZAQ>IWU@W\qLWQD@][Z[GD[EZLNO>W[Z@]ZAQ>I>>I>>>]R[F][EAG]YFADEO>]R^EQW_ZP\[\_^S^ZE[DCkFR]AX\PUMENN\O>Q_DZ^WGSVMM@D@	@FAQ>>I>I>I>>FQ@AFZQ_DZ^WGSVMM@D@>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>FQ@AFZRUXGQ>I>>>>RAZW@][ZZBYQM\UkYBSkC\@VBYPLDRFkX ]D]@Y]B[Z UCkQDP>O>>>>XXk^[U	UFFUM>B[Z UCkQDP	B[Z UCkQDP>>>>A]^LFE^X_@C[	[FZWA_XLGNXRPLDRFkX ]D]@Y]LVL>]Rsx{vuxgokkGWRkWBSB\_k iA]^LFE^X_@C[O>FQ@AFZXXk^[U>I>A]^LFE^X_@C[	sx{vuxgokkGWRkXY\ECNkLB^@kiA]^LFE^X_@C[ >>R[FQUW\A]^LFE^X_@C[UGN@ S^VDL@QB O>>]RN@ S^VDL@QB 			HHN@ S^VDL@QB 			RS^]Q]]ZB@[U O>W[Z@]ZAQ>I>>^BAQDBMNEA\GX	PLDRFkX ]D]@Y]N@ S^VDL@QB >]Rtsx{vuxgokkGWRkY  PFNk i^BAQDBMNEA\GXO>>W[Z@]ZAQ>I>>]Rtsx{vuxgokkGWRkY  PFNk i^BAQDBMNEA\GXYLW ^L@NO>XXk^[Uoi	sx{vuxgokkGWRkDMF\VYFZMki^BAQDBMNEA\GXRS^]Q]]ZB@[U>>>W[Z@]ZAQ>I>>]RB[Z UCkQDP
O>>>XXk^[U	sx{vuxgokkGWRkPE\P] W]XPFFAkiXXk^[UZBYQM\UkYBSkC\@VBY^BAQDBMNEA\GXB[Z UCkQDP>I>I>>FQ@AFZXXk^[U>I>RAZW@][ZF S M\MGDN[EBL>O>[\UNQ[F_RMERY	UFFUM>ANNQ\UUEN	sx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|U_GSMD@V>@FMO>ZLPEN QNN_XAS	UFFUM>]RANNQ\UUENO>ZLPEN QNN_XASoi	sx{vuxgokkGWRkWLGRkXNMY[kiANNQ\UUEN>ZLPEN QNN_XASoi	sx{vuxgokkGWRkWLGRkXNMY[kisx{vuxgokkGWRkWLGRkXNMY[kiANNQ\UUEN>ZLPEN QNN_XASoi	sx{vuxgokkGWRkWLGRkXNMY[kisx{vuxgokkGWRkWLGRkXNMY[kisx{vuxgokkGWRkWLGRkXNMY[kiANNQ\UUEN>>>I>>>ZLPEN QNN_XASoi	NWCUNEM>ZLPEN QNN_XASoi	RS^]Q]]ZB@[U>ZLPEN QNN_XASoi	YLW ^L@N>ZLPEN QNN_XASoi	YLW ^L@N>ZLPEN QNN_XASoi	NWCUNEM>ZLPEN QNN_XASoi	RS^]Q]]ZB@[U>>ZLPEN QNN_XASoi	RS^]Q]]ZB@[U>>>>>@N_PXV\G_	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NG@F]ZStsx{vuxgokkGWRkQZNVM]LkiXSDQk^Y[_N[ >]R@N_PXV\G_		O>N]DBV@\CVQ	sx{vuxgokkGWRkUAU[DUV]kWki@N_PXV\G_		RUXGQ>R[FQUW\sx{vuxgokkGWRkPF]F GWR@ZkiN]DBV@\CVQ@N_PXV\G_UGLUkFX_AZZZFQO>>LUkFX_AZZZFQ	sx{vuxgokkGWRk\G[ML]GWkiLUkFX_AZZZFQ>]RLUkFX_AZZZFQ		O>ZLPEN QNN_XASoi	LUkFX_AZZZFQ>I>I>I>>ZLPEN QNN_XAS	sx{vuxgokkGWRk_SM[G_FkLFk isx{vuxgokkGWRk\QX@@RVGD kiZLPEN QNN_XAS>>>>\FC^GSPV[V DF	sx{vuxgokkGWRkPX^@X\kki@FAQ>[\UNQ[F_RMERY	UFFUM>>R[FQUW\ZLPEN QNN_XASUGPLDRFkX ]D]@Y]O>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]HHtsx{vuxgokkGWRkRGGEPZCXk iPLDRFkX ]D]@Y]O>>>W[Z@]ZAQ>I>]Rsx{vuxgokkGWRkPX^@X\kki@FAQ\FC^GSPV[V DF
O>VFQU_>>>>I>>[\UNQ[F_RMERY	sx{vuxgokkGWRkPE\P] W]XPFFAki[\UNQ[F_RMERYZBYQM\UkYBSkC\@VBYPLDRFkX ]D]@Y]>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>FQ@AFZsx{vuxgokkGWRkk\SZ\YY kisx{vuxgokkGWRk_SM[G_FkLFk i[\UNQ[F_RMERYUFFUMANNQ\UUEN>>>>I>RAZW@][ZPARV_C_EQLDEWQ[_SQ>O>>>@FMO>\QXBB@Z	UFFUMDEWQ[_SQC[Q BXU DEWQ[_SQU_GSMD@V>>>>R[FQUW\\QXBB@ZUGPLDRFkX ]D]@Y]O>>>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]O>W[Z@]ZAQ>I>>>kZQDYW[	[FZWA_XLGNXRPLDRFkX ]D]@Y]>]Rsx{vuxgokkGWRkWBSB\_k ikZQDYW[O>W[Z@]ZAQ>I>R[FQUW\kZQDYW[UG[GD[EZLNO>]Rsx{vuxgokkGWRkQDZV_ki[GD[EZLN			YLW ^L@NkACM_XP_VCUZ YkLPLDRFkX ]D]@Y][GD[EZLN O>FQ@AFZ@FAQ>I>I>>>>R[FQUW\kZQDYW[UG[GD[EZLNO>Z[Y_WX[CBS	PLDRFkX ]D]@Y][GD[EZLN>>>]Rtsx{vuxgokkGWRkY  PFNk iZ[Y_WX[CBSO>>W[Z@]ZAQ>I>Q_CBEMQR	[FZWA_XLGNXRZ[Y_WX[CBSLPLV>]Rsx{vuxgokkGWRkWBSB\_k iQ_CBEMQRO>W[Z@]ZAQ>I>R[FQUW\Q_CBEMQRUG@WS\XZ[QkO>]Rsx{vuxgokkGWRkQDZV_ki@WS\XZ[Qk			C[Q BXUkACM_XP_VCUZ YkLZ[Y_WX[CBS@WS\XZ[QkLULWQO>FQ@AFZ@FAQ>I>I>I>>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>FQ@AFZRUXGQ>I>RAZW@][ZCLCSP[NEQ@NC[>O>@FMO>]RV@  NBWM[ML[CR^N]SFX^UDZ^SGFZFQ@AFZ>>>>]RSQ@k@FUZG]QZ@NWCUNEMO>>FQ@AFZ>I>GQ@k@FUZG]QZ@RS^]Q]]ZB@[U>>Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^] O>FQ@AFZ>I>]RM[YQk NNVYMFB\Rk[NLS^]O>[]\CNNBEZB[Q\APGC[Q BXUXSDQk^Y[_N[  >>FQ@AFZ>I>>>[\UNQ[F_RMERY	F S M\MGDN[EBL>]RQYD@M[\UNQ[F_RMERYO>]RSQ@k@FUZG]QZ@XSDQk^Y[_N[ O>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ U_GSMD@V>GQ@k@FUZG]QZ@XSDQk^Y[_N[ LRLU>I>GQ@k@FUZG]QZ@XSDQk^Y[_N[ LQRL>FQ@AFZ>I>DW@EkFRCQC 	>R[FQUW\[\UNQ[F_RMERYUGDEWQ[_SQO>>]RPARV_C_EQLDEWQ[_SQO>>>W[Z@]ZAQ>>>I>>DBZQDBR[@	>ULLQ]SRVEM	DEWQ[_SQU_GSMD@V >]Rtsx{vuxgokkGWRkC]GF]@NDXNZk iULLQ]SRVEMtsx{vuxgokkGWRkY  PFNk iULLQ]SRVEMO>ULLQ]SRVEM	ZAXX>IQXGQ]Rtsx{vuxgokkGWRkY  PFNk iULLQ]SRVEMO>GEWVN@XUE@ P\\ZULLQ]SRVEM@FAQ>I>]RULLQ]SRVEMtsx{vuxgokkGWRkY  PFNk iULLQ]SRVEMHHtsx{vuxgokkGWRk_XXP] C^Mk iULLQ]SRVEMO>>ULLQ]SRVEM	ZAXX>I>]RULLQ]SRVEMO>D_[FFW kQAG	ULLQ]SRVEM\ASSNCBDS[ZG^>@[PDLWQRDQENR	MV\Yk_]LXPMRk[NLS^]>CVAPFRRXRA	_ W^\V CPNY_D_[FFW kQAG@[PDLWQRDQENRC[Q BXU>]RCVAPFRRXRACVAPFRRXRA
	sx{vuxgokkGWRkD@WYYENNCMMkki@[PDLWQRDQENRO>DBZQDBR[@	D_[FFW kQAG>I>I>>>>>>>]RDBZQDBR[@O>@C@\CPVRYk	sx{vuxgokkGWRk[\CPGL _]GZki\ASSNCBDS[ZG^du`|}zr{kr}xqzuyq>GZP@_CUQCEB 	DEWQ[_SQC[Q BXU@C@\CPVRYk>]Rtsx{vuxgokkGWRkY  PFNk iGZP@_CUQCEB O>GEWVN@XUE@ P\\ZGZP@_CUQCEB   @FAQ>I>D_[FFW kQAG	GZP@_CUQCEB \ASSNCBDS[ZG^>@[PDLWQRDQENR	MV\Yk_]LXPMRk[NLS^]>CVAPFRRXRA	_ W^\V CPNY_D_[FFW kQAG@[PDLWQRDQENRYLW ^L@N>]RCVAPFRRXRACVAPFRRXRA
	sx{vuxgokkGWRkD@WYYENNCMMkki@[PDLWQRDQENRO>>DBZQDBR[@	D_[FFW kQAG>>VUGQZUYQ	@C@\CPVRYk\ASSNCBDS[ZG^>LQAV@S\W]LM]PR[QZDEWQ[_SQVUGQZUYQ>I>I>]RDBZQDBR[@O>W[Z@]ZAQ>>I>CUB_YSQVGGNP[_BDBZQDBR[@>SUB\XXALLBWR W\F XDBZQDBR[@>DW@EkFRCQC >I>]RDW@EkFRCQC 
O>GQ@k@FUZG]QZ@U_GSMD@V>IQXGQO>GQ@k@FUZG]QZ@RS^]Q]]ZB@[U >I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>>I>RAZW@][ZLQAV@S\W]LM]PR[QZDEWQ[_SQVUGQZUYQ>O>@FMO>VCAWL]ARV N	DEWQ[_SQC[Q BXU>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiVCAWL]ARV NO>VCAWL]ARV N	sx{vuxgokkGWRkWLGRkXNMY[kiDEWQ[_SQXSDQk^Y[_N[ >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiVCAWL]ARV NO>FQ@AFZ>I>I>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iVCAWL]ARV N>]RNENDELUZDQD^Z\BO>FQ@AFZ>I>^[EW] S^_C	>DFQR]L	>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEMNENDELUZDQD^Z\BWCLB@]UGO>^[EW] S^_C	WCLB@]UGoi>I>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ NENDELUZDQD^Z\BWCLB@]UGO>DFQR]L	WCLB@]UGoi>I>]R^[EW] S^_CHHDFQR]LHHsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[UDFQR]LO>FQ@AFZ>I>CDPV	sx{vuxgoC[Q BXUi>]Rsx{vuxgokkGWRk@L\SQY@ZAkiCDPVHHsx{vuxgokkGWRkUU\RUWEQkiCDPVXSDQk^Y[_N[ O>FQ@AFZ>I>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U ^[EW] S^_CO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UXSDQk^Y[_N[ >FQ@AFZ>I>>>>VLGZ[DZFQ	T^[EW] S^_CNWCUNEMDFQR]LC[Q BXU>CDPV
EAQFMU_GSMD@V>_EQXYED]PGVQ	CDPV
SQ@kBUFgNWCUNEMVLGZ[DZFQXSDQk^Y[_N[ NWCUNEMNWCUNEM>]R_EQXYED]PGVQ			ZAXXO>CDPV
EAQFMC[Q BXU>FQ@AFZ>I>^]MFR[G 	BQF@[YVS[USFV@_EQXYED]PGVQ>>>]Rsx{vuxgokkGWRkWBSB\_k i^]MFR[G O>CDPV
EAQFMNWCUNEM >FQ@AFZ>I>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iVUGQZUYQ^]MFR[G @FAQO>>CDPV
EAQFMXSDQk^Y[_N[ >>FQ@AFZ>I>^]MFR[G oi	VUGQZUYQ>^]MFR[G 	sx{vuxgokkGWRkSENUGEEAMZk i^]MFR[G >>D\PUGLDR 	sx{vuxgokkGWRkS[G]P_P[Zki^]MFR[G >_ELRS]^C	CDPV
EAQFMCDPV
DFQDUFQaXSDQk^Y[_N[ VLGZ[DZFQYLW ^L@NYLW ^L@ND\PUGLDR >>>>]R_ELRS]^C			RUXGQO>[]\CNNBEZB[Q\APGYLW ^L@NU_GSMD@V>CDPV
EAQFMYLW ^L@N>FQ@AFZ>>>I>>CDPV
EAQFMYLW ^L@N>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>tCDkWUW\QkPQXQ@QC[Q BXURS^]Q]]ZB@[U >>>tCDkWUW\QkPQXQ@QXSDQk^Y[_N[ RS^]Q]]ZB@[U >I>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>]Rsx{vuxgokkGWRk@L\SQY@ZAkisx{vuxgoU_GSMD@ViO>tsx{vuxgoNWCUNEMi
EAQFMYLW ^L@N>I>>>>IWU@W\qLWQD@][Z[GD[EZLNO>>>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>]Rsx{vuxgokkGWRk@L\SQY@ZAkisx{vuxgoRS^]Q]]ZB@[UiO>tsx{vuxgoU_GSMD@Vi
EAQFMNWCUNEM>I>I>I>RAZW@][Z_\F]_^UQ_B^N>O>G@U@]WNENDELUZDQD^Z\B	ZAXX>]RNENDELUZDQD^Z\B		ZAXXFQ@AFZNENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VO>>NENDELUZDQD^Z\B	>FQ@AFZNENDELUZDQD^Z\B>>>>I>NENDELUZDQD^Z\B	tSN]ZRXU@Qsx{vuxgokkGWRkWBDQ[VVAZE\kiRS^]Q]]ZB@[U>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\BLL RNENDELUZDQD^Z\B	>FQ@AFZNENDELUZDQD^Z\B>>I>RAZW@][Z[QFR\V]XM]NYZP>O>@FMO>]RPQR]ZQPYLW ^L@NFQ@AFZ>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N>XDN^VABEUF	SL@D ]FAVZuvgdu`|NWCUNEMXSDQk^Y[_N[ >^[MRNREY 	SL@D ]FAVZuvgdu`|NWCUNEM LL>NCYZX^^D@Y	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V W[Z@QZ@kAFX>]RNCYZX^^D@Y			O>>>>NCYZX^^D@Y	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NSQ@kG]@QkAFXC[Q BXU >I>V L\^BR]WNEPU	sx{vuxgokkGWRkR_]RRR^ ESkiRS^]Q]]ZB@[U C[Q BXU  NCYZX^^D@YXDN^VABEUF>]Rsx{vuxgokkGWRkUAU[DUV]kWkiV L\^BR]WNEPURS^]Q]]ZB@[U  		V L\^BR]WNEPU	NWCUNEM  sx{vuxgokkGWRkBL_FA]]]WPkiV L\^BR]WNEPU>kNFWAMS\FWGQ	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U \[YQkAFXXSDQk^Y[_N[  NBUZPGUYBEXCYLW ^L@N >]RkNFWAMS\FWGQ			kNFWAMS\FWGQ	C[Q BXU  ]]Ak[ZG\^^RAP]UMARS^]Q]]ZB@[U NBUZPGUYBEXCXSDQk^Y[_N[  >>>>]Rsx{vuxgokkGWRkUAU[DUV]kWkikNFWAMS\FWGQYLW ^L@N  		kNFWAMS\FWGQ	NWCUNEM  sx{vuxgokkGWRkBL_FA]]]WPkisx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@V kNFWAMS\FWGQ>>L@GMFS\SR@CU@Q	]GGQ@sx{vuxgoC[Q BXU  isx{vuxgokkGWRkCGC  VMVVk isx{vuxgoXSDQk^Y[_N[   isx{vuxgoRS^]Q]]ZB@[U  i>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@QLL O>L@GMFS\SR@CU@Q	kP^D_FS\YY WU_GSMD@V >I>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@QLQLO>L@GMFS\SR@CU@Q	_\F]_^UQ_B^N>I>@ZSYC	>]R]GGQ@sx{vuxgoU_GSMD@V   isx{vuxgokkGWRkCGC  VMVVk isx{vuxgoC[Q BXUisx{vuxgokkGWRkD@WYYENNCMMkkisx{vuxgoYLW ^L@Ni
 jO>>@ZSYC	sx{vuxgoYLW ^L@Ni>IQXGQO>>>@ZSYC	kP^D_FS\YY WNWCUNEM>I>>>]Rsx{vuxgokkGWRkD@WYYENNCMMkki@ZSYC
LWLO>>YSWP_GN@FXXRS^]Q]]ZB@[U@ZSYCYLW ^L@N>I>SkZ[WXDRN@	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxkdu`|>]RSkZ[WXDRN@			SkZ[WXDRN@	>>]Rsx{vuxgokkGWRkQDZV_kiSkZ[WXDRN@		SkZ[WXDRN@	>>YXGN Z^]V@_	UFFUM>U_GSMD@V	
Lk_@Y ZRB]][LD VZY]>YLW ^L@N	
MDU[^WVEZSEkNXZV]\>C[Q BXU	
SkZ[WXDRN@>>>>DQAL _BLZB	UFFUM>YLW ^L@N	
V L\^BR]WNEPU>>RS^]Q]]ZB@[U	
kMZ[W\L[YU[>>>C[Q BXU	
kNFWAMS\FWGQ>NWCUNEM	
SL@D ]FAVZuvgdu`|RS^]Q]]ZB@[U>NWCUNEM	
@ZSYC>>kNMFPY	M_E@QREC][C[Q BXU>]Rsx{vuxgokkGWRkCGC  VMVVk ikNMFPYHHsx{vuxgokkGWRkD@WYYENNCMMkkikNMFPY			O>FQ@AFZ>I>>CLBR^YRkYG ME	sx{vuxgokkGWRkV\W][LkiRPSR]FXSNC^E@sx{vuxgokkGWRkPDZXFZEVS\SkiDQAL _BLZBkNMFPY>\NZNB[US_	U_GSMD@V sx{vuxgokkGWRkV\W][Lkisx{vuxgokkGWRkPDZXFZEVS\SkiYXGN Z^]V@_C[Q BXU>\NZNB[US_	YLW ^L@NCLBR^YRkYG MERS^]Q]]ZB@[U>>DCk[@WB	sx{vuxgokkGWRkk[AFM@ZWUECkiG@F]ZSL@GMFS\SR@CU@QG@F]ZS@ZSYCkNMFPYsx{vuxgokkGWRkPDZXFZEVS\SkiYXGN Z^]V@_oRS^]Q]]ZB@[Uisx{vuxgokkGWRkPDZXFZEVS\SkiYXGN Z^]V@_oNWCUNEMiHsx{vuxgokkGWRkX@FXki]]Ak[ZG\^^RAP]UMAHSkZ[WXDRN@>]RYSWP_GN@FXXNWCUNEM\NZNB[US_C[Q BXUHHkP^D_FS\YY WXSDQk^Y[_N[ 			\NZNB[US_YSWP_GN@FXXNWCUNEMDCk[@WBXSDQk^Y[_N[ >>>>AZGQ@DCk[@WB>BYB]RZW ]	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  \[YQkAFXXSDQk^Y[_N[  NBUZPGUYBEXCYLW ^L@N >]RBYB]RZW ]			BYB]RZW ]	NWCUNEM  ]]Ak[ZG\^^RAP]UMARS^]Q]]ZB@[U NBUZPGUYBEXCNWCUNEM>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiBYB]RZW ]C[Q BXU  		BYB]RZW ]	YLW ^L@N  sx{vuxgokkGWRkBL_FA]]]WPkisx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@V BYB]RZW ]>YSWP_GN@FXXXSDQk^Y[_N[   BYB]RZW ]U_GSMD@V>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@Q O>FQ@AFZ>I>>>>YSWP_GN@FXXU_GSMD@VL@GMFS\SR@CU@QYLW ^L@N>]RBZVkBZC[SWGQFQ@AFZ>L \DERMNRVW	GM_EAV^VFW>]Rtsx{vuxgokkGWRkY  PFNk iL \DERMNRVWGEWVN@XUE@ P\\ZL \DERMNRVW @FAQ>]Rtsx{vuxgokkGWRkY  PFNk iL \DERMNRVWHHtsx{vuxgokkGWRk_XXP] C^Mk iL \DERMNRVWFQ@AFZ>>_G]@WQASEQ]^	L \DERMNRVW^[MRNREY YLW ^L@N >RWML^UkDSUR	FG@C SM^kXMSMQR>RS^]Q]]ZB@[U>UFFUMkkgxaskkkkn}dkzuyqkkkkcf}`qkqmkkkkbqfg}{zkk>UFFUMkMZ[W\L[YU[XDN^VABEUFSL@D ]FAVZuvgdu`|U_GSMD@VLLXCDS]V]N]\U[DX C>>]RRWML^UkDSURO>]R]Z@SQ@k[D@][ZC[Q BXU
[]\CNNBEZB[Q\APGNWCUNEMXSDQk^Y[_N[ >FQ@AFZ>I>]Rtsx{vuxgokkGWRk\]XDEBSkWEki_G]@WQASEQ]^HHsx{vuxgokkGWRkk[AFM@ZWUECki^UNF\NZMLZLZkN[XAG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk i_G]@WQASEQ]^		sx{vuxgokkGWRkk[AFM@ZWUECkiRWML^UkDSURO>_ W^\V CPNY__G]@WQASEQ]^RWML^UkDSURNWCUNEM>M^EGF^k]GM C[ZM _G]@WQASEQ]^P[SC\_^CNZQR^SR@>SUB\XXALLBWR W\F X_G]@WQASEQ]^>RkV [kV DU^__G]@WQASEQ]^>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZFG@C SM^kXMSMQR_QMPRBURNEB[ \]_SS]^MCS^^ WM>O>>AMQACkQBCNU^	ZAXX>]RAMQACkQBCNU^			ZAXXO>>>>AMQACkQBCNU^	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMSQ@k@FUZG]QZ@DPAZGEVRQCQ_RUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^O>AMQACkQBCNU^	BNGBN E@XYFNMSBYLW ^L@NRUXGQ>I>]Rsx{vuxgokkGWRkWBSB\_k iAMQACkQBCNU^O>AMQACkQBCNU^	UFFUM>I>I>BZ^GEBSkk\D^	>]R]GGQ@AMQACkQBCNU^o_QMisx{vuxgokkGWRkCGC  VMVVk iAMQACkQBCNU^o_QMiO>BZ^GEBSkk\D^	AMQACkQBCNU^o_QMi>I>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiBZ^GEBSkk\D^jO>BZ^GEBSkk\D^	kP^D_FS\YY W_QM>I>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiBZ^GEBSkk\D^LLFQ@AFZRUXGQ>Y@Z[D[X	sx{vuxgokkGWRkWBDQ[VVAZE\kiBZ^GEBSkk\D^@FAQ>]RY@Z[D[XHHsx{vuxgokkGWRkD@WYYENNCMMkkiY@Z[D[XLLUFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiY@Z[D[XYLW ^L@N 			RUXGQFQ@AFZRUXGQ>Y@Z[D[X	sx{vuxgokkGWRkR_]RRR^ ESkiPRBURNEB[ \]_SS]^MCS^^ WMY@Z[D[X>]RPQR]ZQPXSDQk^Y[_N[   O>@FMO>>t@[_QZkSQ@kUXXY@Z[D[X`{qzkdufgq>IWU@W\`\F[CUVXQ[GD[EZLNO>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>FQ@AFZRUXGQ>I>IQXGQ]RM[YQk NNVYMFB\Y@Z[D[XO>>>FQ@AFZRUXGQ>>I>>>FQ@AFZY@Z[D[X>I>>RAZW@][Z_VC@]kZVFR>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZ>]RPQR]ZQPRS^]Q]]ZB@[UFQ@AFZ>WYNGDVQ	L@PXLU]RYZ>>>]RWYNGDVQO>[QFR\V]XM]NYZP>WYNGDVQ	L@PXLU]RYZ>I>PF_VMM^Q	kP^D_FS\YY WNWCUNEM>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiPF_VMM^Q			PF_VMM^Q	sx{vuxgokkGWRkD]LA]Q^VkihL>]kQYZ]GX\P	]GGQ@sx{vuxgoC[Q BXUisx{vuxgokkGWRkCGC  VMVVk isx{vuxgoC[Q BXUisx{vuxgokkGWRkD@WYYENNCMMkkisx{vuxgoYLW ^L@Ni
	 sx{vuxgoRS^]Q]]ZB@[UikP^D_FS\YY WYLW ^L@N>]Rsx{vuxgokkGWRkD@WYYENNCMMkki]kQYZ]GX\P]kQYZ]GX\P	_\F]_^UQ_B^N>>>GBQE\^DZ^PG	]GGQ@sx{vuxgoU_GSMD@Visx{vuxgokkGWRkCGC  VMVVk isx{vuxgoU_GSMD@Visx{vuxgokkGWRkD@WYYENNCMMkkisx{vuxgoU_GSMD@Vi
j sx{vuxgoU_GSMD@VikP^D_FS\YY WYLW ^L@N>WYNVURW^RBGG	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxkdu`|>]RWYNVURW^RBGG			WYNVURW^RBGG	>]Rsx{vuxgokkGWRkQDZV_kiWYNVURW^RBGG		WYNVURW^RBGG	>_NLNARC@N]	sx{vuxgokkGWRkk[AFM@ZWUECki]kQYZ]GX\PGBQE\^DZ^PGPF_VMM^Qsx{vuxgokkGWRkPDZXFZEVS\SkiLk_@Y ZRB]][LD VZY]sx{vuxgokkGWRkPDZXFZEVS\SkiMDU[^WVEZSEkNXZV]\Hsx{vuxgokkGWRkX@FXki]]Ak[ZG\^^RAP]UMAHWYNVURW^RBGG>>>>AZGQ@WYNVURW^RBGG>]RkP^D_FS\YY WNWCUNEM		_NLNARC@N]O>>>[QFR\V]XM]NYZP>WYNGDVQ	L@PXLU]RYZ>I>]RBZVkBZC[SWGQFQ@AFZ>M YGAF^PE@ZQB	AEZGREWF[>NFE]ZWFZGMZ	tsx{vuxgokkGWRk\]XDEBSkWEkiM YGAF^PE@ZQBYLW ^L@N>]RNFE]ZWFZGMZWYNGDVQSQ@k@FUZG]QZ@RS^]Q]]ZB@[UFQ@AFZ>]k QVCVkCZ^_Zk>>>\XkSZUYS\_N>^k@VD ^UA]_LNM>RSQSFCA A@^G	tsx{vuxgokkGWRk\]XDEBSkWEkiM YGAF^PE@ZQBXSDQk^Y[_N[ >WYNGDVQ	L@PXLU]RYZ>]RRSQSFCA A@^GWYNGDVQO>GQ@k@FUZG]QZ@YLW ^L@N>>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>I>I>RAZW@][Z\XkSZUYS\_N>O>@FMO>]RPQR]ZQPC[Q BXUFQ@AFZ>M YGAF^PE@ZQB	AEZGREWF[>L \DERMNRVW	GM_EAV^VFW>VDW@C\WR\FA YA	SL@D ]FAVZuvgdu`|YLW ^L@N RS^]Q]]ZB@[U >>YEU@ZW_X	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtsx{vuxgokkGWRkQZNVM]LkiYLW ^L@NRUXGQ>YEU@ZW_X	sx{vuxgokkGWRkCGC  VMVVk iYEU@ZW_Xsx{vuxgokkGWRk\G[ML]GWkiYEU@ZW_X>]RYEU@ZW_X			HHsx{vuxgokkGWRkCLA\Z G^_L_kiYEU@ZW_XC[Q BXU			YEU@ZW_X	NWCUNEM>S_CLZ@X]_^^ 	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>LDDV@LRNU	PQR]ZQPC[Q BXUcdkw{z`qz`kp}fU_GSMD@VS_CLZ@X]_^^ >_[N ZA[D[Z\^_	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBNWCUNEMsx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZC[Q BXUsx{vuxgokkGWRkDMF\VYFZMkiL \DERMNRVWU_GSMD@Vsx{vuxgokkGWRkDMF\VYFZMkiS_CLZ@X]_^^ RS^]Q]]ZB@[Usx{vuxgokkGWRkDMF\VYFZMkiLDDV@LRNURS^]Q]]ZB@[U>]RPQR]ZQPNWCUNEM_[N ZA[D[Z\^_oi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fNWCUNEM>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk i_[N ZA[D[Z\^_UGU@AQDW\BS[SO>RBS@XAAMA	U@AQDW\BS[SVDW@C\WR\FA YA>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRBS@XAAMAQNDFDLWZkF@@LXFARBS@XAAMAZAXX>BMNVG]EY@V[M\	U@AQDW\BS[SC[Q BXUVDW@C\WR\FA YA>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiBMNVG]EY@V[M\QNDFDLWZkF@@LXFABMNVG]EY@V[M\ZAXX>>>I>AZGQ@S_CLZ@X]_^^ LDDV@LRNU_[N ZA[D[Z\^_U@AQDW\BS[SRBS@XAAMABMNVG]EY@V[M\>VEZ\QDkUZk	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|C[Q BXU>>>]RPQR]ZQPC[Q BXUVEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fYLW ^L@N>VEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBNWCUNEM >VEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZYLW ^L@N >R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk iVEZ\QDkUZkUGM\Xk@[E^AZO>BPW^ RSUY	M\Xk@[E^AZYEU@ZW_X>MkQRSWYPRX	tsx{vuxgokkGWRk@Y@R NPPDCC@kiBPW^ RSUYtsx{vuxgokkGWRkBYEVDGkUNk iBPW^ RSUY>]Rsx{vuxgokkGWRkCGC  VMVVk iMkQRSWYPRXHHMkQRSWYPRX			HHsx{vuxgokkGWRkUAU[DUV]kWkiMkQRSWYPRXVDW@C\WR\FA YA			RUXGQW[Z@]ZAQ>QVMXB\kSkVU	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@Vsx{vuxgokkGWRkFSCP[[U^kiVDW@C\WR\FA YANWCUNEMhZMkQRSWYPRX>]Rsx{vuxgokkGWRkCGC  VMVVk iQVMXB\kSkVUQVMXB\kSkVU		MkQRSWYPRX^EQW_ZP\[\_^S^BPW^ RSUYQVMXB\kSkVU[]\CNNBEZB[Q\APGXSDQk^Y[_N[ XSDQk^Y[_N[ >>>>I>>>>AZGQ@VEZ\QDkUZkM\Xk@[E^AZBPW^ RSUYMkQRSWYPRXQVMXB\kSkVU>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>tPQXQ@Qk[D@][ZXSDQk^Y[_N[ >tPQXQ@Qk[D@][ZXSDQk^Y[_N[ >>>>tPQXQ@Qk[D@][ZYLW ^L@N>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>I>I>RAZW@][ZXGQUVSENX[NNVPU\F>O>@FMO>>>]RPQR]ZQPC[Q BXUFQ@AFZ>M YGAF^PE@ZQB	AEZGREWF[>>>L \DERMNRVW	GM_EAV^VFW>>VDW@C\WR\FA YA	SL@D ]FAVZuvgdu`|U_GSMD@V XSDQk^Y[_N[  >>S_CLZ@X]_^^ 	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >LDDV@LRNU	PQR]ZQPYLW ^L@Ncdkw{z`qz`kp}fU_GSMD@VS_CLZ@X]_^^ >>>_[N ZA[D[Z\^_	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBXSDQk^Y[_N[ sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[Usx{vuxgokkGWRkDMF\VYFZMkiL \DERMNRVWXSDQk^Y[_N[ sx{vuxgokkGWRkDMF\VYFZMkiS_CLZ@X]_^^ XSDQk^Y[_N[ sx{vuxgokkGWRkDMF\VYFZMkiLDDV@LRNUYLW ^L@N>>]RPQR]ZQPNWCUNEM_[N ZA[D[Z\^_oi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fYLW ^L@N>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk i_[N ZA[D[Z\^_UGU@AQDW\BS[SO>EXU@SYLQGZ	U@AQDW\BS[SVDW@C\WR\FA YA>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiEXU@SYLQGZQNDFDLWZkF@@LXFAEXU@SYLQGZZAXX>I>AZGQ@S_CLZ@X]_^^ LDDV@LRNU_[N ZA[D[Z\^_U@AQDW\BS[SEXU@SYLQGZ>_PQWSZ^V	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|XSDQk^Y[_N[ >]RPQR]ZQPXSDQk^Y[_N[ _PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fNWCUNEM>>_PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBU_GSMD@V>_PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk i_PQWSZ^VUGAAVRFMFUVO>BMNVG]EY@V[M\	AAVRFMFUVU_GSMD@V>Q][B\QLV	tsx{vuxgokkGWRk@Y@R NPPDCC@kiBMNVG]EY@V[M\tsx{vuxgokkGWRkBYEVDGkUNk iBMNVG]EY@V[M\>]Rsx{vuxgokkGWRkCGC  VMVVk iQ][B\QLVHHQ][B\QLV			HHsx{vuxgokkGWRkUAU[DUV]kWkiQ][B\QLVVDW@C\WR\FA YA			RUXGQW[Z@]ZAQ>>>>\kRXXNGZLCZA	XSZQYY@]R@[EG^@Q][B\QLVVDW@C\WR\FA YA>]Rsx{vuxgokkGWRkCGC  VMVVk i\kRXXNGZLCZA\kRXXNGZLCZA		Q][B\QLV^EQW_ZP\[\_^S^BMNVG]EY@V[M\\kRXXNGZLCZA[]\CNNBEZB[Q\APGXSDQk^Y[_N[ C[Q BXU>I>AZGQ@_PQWSZ^VAAVRFMFUVBMNVG]EY@V[M\Q][B\QLV\kRXXNGZLCZA>]Rsx{vuxgokkGWRkLEG\G\DMQADki			U_GSMD@V FQ@AFZ>]RGDEXD]\ZFQ@AFZ>]RBZVkBZC[SWGQFQ@AFZ>@@[_WLWUYQ	L \DERMNRVWNWCUNEM>GFCCMEMBEZ_	YLW ^L@NhZ>YLW ^L@NhZRS^]Q]]ZB@[U hZNWCUNEMhZ>>>>NWCUNEMhZU_GSMD@VhZNWCUNEMhZ>XSDQk^Y[_N[ hZ>>>>B_\EWNU^LC	tsx{vuxgokkGWRk\]XDEBSkWEki@@[_WLWUYQ>WAFFQZ@	B_\EWNU^LCtsx{vuxgokkGWRkBYEVDGkUNk i@@[_WLWUYQ>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGU_GSMD@VC[Q BXU>FQ@AFZ>I>GM^k  GCXMZNW	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|NWCUNEM>]RPQR]ZQPXSDQk^Y[_N[ GM^k  GCXMZNWoi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fYLW ^L@N>]RPQR]ZQPXSDQk^Y[_N[ GM^k  GCXMZNWoi	sx{vuxgokkGWRkDMF\VYFZMkicdyakdxas}zkp}fRS^]Q]]ZB@[U>]RPQR]ZQPU_GSMD@VGM^k  GCXMZNWoi	sx{vuxgokkGWRkDMF\VYFZMkicdkdxas}zkp}fYLW ^L@N>>GA]NSZPNF	sx{vuxgokkGWRkDMF\VYFZMkiL \DERMNRVWRS^]Q]]ZB@[U>WWXD]APD	sx{vuxgokkGWRkUFBG[ZLZN Gk iGA]NSZPNFGM^k  GCXMZNW@FAQ>AZGQ@GM^k  GCXMZNWGA]NSZPNF>]RWWXD]APDO>WRPUXCVUN^@E	L \DERMNRVWRS^]Q]]ZB@[U >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiWRPUXCVUN^@E_ W^\V CPNY_WRPUXCVUN^@ENWCUNEM>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@U_GSMD@V			RUXGQO>Y@kYS ZBZ	WAFFQZ@>]RWAFFQZ@		sx{vuxgokkGWRkQDZV_kiWAFFQZ@		hZWAFFQZ@	hZ>AYZ]RZWU_ADX	tsx{vuxgokkGWRkBYEVDGkUNk i@@[_WLWUYQ>>]Rsx{vuxgokkGWRkCGC  VMVVk iAYZ]RZWU_ADXAYZ]RZWU_ADX	>]RAYZ]RZWU_ADX		Y@kYS ZBZO>[]\CNNBEZB[Q\APGYLW ^L@NRS^]Q]]ZB@[U>IQXGQO>^EQW_ZP\[\_^S^@@[_WLWUYQWAFFQZ@GFCCMEMBEZ_>>>>M^EGF^k]GM C[ZM @@[_WLWUYQP[SC\_^CNZQR^SR@>]RB_\EWNU^LCSUB\XXALLBWR W\F X@@[_WLWUYQ  >I>>AZGQ@AYZ]RZWU_ADXY@kYS ZBZ>>>I>I>AZGQ@WWXD]APDWRPUXCVUN^@EB_\EWNU^LC>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>>>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>I>>>>I>RAZW@][ZL\XXZD _ZkZ >O>@FMO>]RPQR]ZQPU_GSMD@VFQ@AFZ>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZ>SASXkDk  _	SL@D ]FAVZuvgdu`|YLW ^L@N>Rk[NLS^]	Z@SSV]@AXS]ZZY>>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^] FQ@AFZ>BZ^GEBSkk\D^	WU^YMASDXk_GG>>>WAFFQZ@	tSQ@k[D@][ZSASXkDk  _>]RWAFFQZ@sx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@			sx{vuxgokkGWRkD@WYYENNCMMkkiBZ^GEBSkk\D^WAFFQZ@			BZ^GEBSkk\D^FQ@AFZ>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>ADPU@Qk[D@][ZSASXkDk  _BZ^GEBSkk\D^NWCUNEM>IQXGQ]RPQR]ZQPXSDQk^Y[_N[ PQR]ZQPC[Q BXUPQR]ZQPNWCUNEMPQR]ZQPXSDQk^Y[_N[ sx{vuxgokkGWRkQk[VUA]AQRk iNWCUNEM O>\E]ULU_Z^QV	RS^]Q]]ZB@[U>@PZ]LRNLBB	tZQC\E]ULU_Z^QVW[ZG@UZ@YLW ^L@NW[ZG@UZ@YLW ^L@NW[ZG@UZ@YLW ^L@NW[ZG@UZ@XSDQk^Y[_N[ >]R@PZ]LRNLBB@PZ]LRNLBB
W[ZZQW@kQFFZ[O>DFQR]L	]GGQ@sx{vuxgoRS^]Q]]ZB@[Ui
DFQR]Lsx{vuxgoXSDQk^Y[_N[ i
DFQR]LRS^]Q]]ZB@[U>>N GD_NPS	@PZ]LRNLBB
FQUXkQGWUDQkG@F]ZSBZ^GEBSkk\D^>ECC@B	@PZ]LRNLBB
FQUXkQGWUDQkG@F]ZSSASXkDk  _>@PZ]LRNLBB
EAQFM}zhLhL f`hL zhL {ODFQR]LI[DhL hLhLRhLQGhLRhLhL hLhLRhLQkhLQUYhL[D@hLhLRZkBUXAhLUA@[hLW[UPhLhL hL WahL hLOECC@BION GD_NPSIZhLRhL RhL Qpadx}wuhL qhL VqmhLhLphL `q[hL@][hLQkBUhLWAQ	ON GD_NPSI>]R@PZ]LRNLBB
QFF[F[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UYLW ^L@Nsx{vuxgokkGWRkQDZV_ki@PZ]LRNLBB
QFF[Fj>@PZ]LRNLBB
WX[GQ>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZAQ_^@\LQBMLA[XS>O>>NN^EXS[BQQLDWZ	PQR]ZQPC[Q BXUcdkw{z`qz`kp}fuvgdu`|RS^]Q]]ZB@[U>YMN[U\CB@ RCGX	SL@D ]FAVZuvgdu`|C[Q BXU>FQ@AFZUFFUMNN^EXS[BQQLDWZU_GSMD@VNN^EXS[BQQLDWZU_GSMD@V YMN[U\CB@ RCGXC[Q BXU YMN[U\CB@ RCGX>I>RAZW@][Z@XBCNVNES\Q^BSACMAk>O>G[Wk\XEWBBV	]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiS\Q^BSACMAk>]RG[Wk\XEWBBVLLWHHG[Wk\XEWBBV
FQ@AFZRUXGQ>>^FX@FL[Mk_Q^	tsx{vuxgokkGWRkBYEVDGkUNk iS\Q^BSACMAk>]Rsx{vuxgokkGWRkCGC  VMVVk i^FX@FL[Mk_Q^HHsx{vuxgokkGWRkD@WYYENNCMMkki^FX@FL[Mk_Q^HHsx{vuxgokkGWRkD@WYYENNCMMkki^FX@FL[Mk_Q^
 FQ@AFZRUXGQ>LUkFX_AZZZFQ	sx{vuxgokkGWRkPF]F GWR@Zki^FX@FL[Mk_Q^>]Rsx{vuxgokkGWRkEMVLY\AkiLUkFX_AZZZFQHHLUkFX_AZZZFQoi		U_GSMD@V HHsx{vuxgokkGWRkD@WYYENNCMMkkiLUkFX_AZZZFQoiFQ@AFZRUXGQ>AYP BG^ B	tsx{vuxgokkGWRkWBDQ[VVAZE\kiLUkFX_AZZZFQoi>]RAYP BG^ B			RUXGQHHsx{vuxgokkGWRkD@WYYENNCMMkkiAYP BG^ BL LQFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkQDZV_kiAYP BG^ B			hLRhLVO>Y]UPYP\MRk	tsx{vuxgokkGWRk[RP^kXQF \[Ekibsx{vuxgokkGWRkQDZV_kiAYP BG^ B j >]Rsx{vuxgokkGWRkWBSB\_k iY]UPYP\MRkHHY]UPYP\MRkoiHHY]UPYP\MRkoi
  FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  AYP BG^ B	tSNPQW[PQAYP BG^ B >QXGQ]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>AYP BG^ B	tSN]ZRXU@Qsx{vuxgokkGWRkQDZV_kiAYP BG^ BLLsx{vuxgokkGWRkD@WYYENNCMMkkiAYP BG^ Bj  >]Rsx{vuxgokkGWRkCGC  VMVVk iAYP BG^ Bsx{vuxgokkGWRkD@WYYENNCMMkkiAYP BG^ B
 FQ@AFZRUXGQ>IQXGQFQ@AFZRUXGQ>I>>]Rsx{vuxgokkGWRkCGC  VMVVk iAYP BG^ BHHsx{vuxgokkGWRkD@WYYENNCMMkkiAYP BG^ BHHsx{vuxgokkGWRkQDZV_kiAYP BG^ B 		U_GSMD@VHHsx{vuxgokkGWRkk[AFM@ZWUECkiAYP BG^ B		LUkFX_AZZZFQoiFQ@AFZRUXGQ>FQ@AFZAYP BG^ B>I>RAZW@][ZZP_kQXYW_>O>@FMO>]RPQR]ZQPYLW ^L@N  FQ@AFZ>UBGW\X\ZU S	AQ_^@\LQBMLA[XS>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiUBGW\X\ZU SoiFQ@AFZ>>]R@XBCNVNEUBGW\X\ZU Soi			RUXGQFQ@AFZ>Y@Z[D[X	FG@C SM^kXMSMQRNWCUNEM UFFUMkkgxaskkUFFUMsx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZC[Q BXU >]Rsx{vuxgokkGWRkCGC  VMVVk iY@Z[D[XHHY@Z[D[X			FQ@AFZ>Y@Z[D[X	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[U Y@Z[D[X>]Rsx{vuxgokkGWRkCGC  VMVVk iY@Z[D[XHHY@Z[D[X			FQ@AFZ>>NRU PPPEFXE	XCDS]V]N]\U[DX CSL@D ]FAVZuvgdu`|RS^]Q]]ZB@[U >M MNEB\\BZFR	YLW ^L@N NRU PPPEFXEC[Q BXU >MFkYLAQVWkNk	RS^]Q]]ZB@[U NRU PPPEFXENWCUNEM>^Y[_Z^BXM^Y	RS^]Q]]ZB@[UUBGW\X\ZU SoiU_GSMD@VXCDS]V]N]\U[DX CNWCUNEMhZY@Z[D[X>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiUBGW\X\ZU SoiO>>>>]RMRFkUDFEFUZUBGW\X\ZU SoiO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ U_GSMD@V>FQ@AFZ>I>]R^EQW_ZP\[\_^S^UBGW\X\ZU Soi^Y[_Z^BXM^YO>M^EGF^k]GM C[ZM UBGW\X\ZU SoiP[SC\_^CNZQR^SR@>>>>SUB\XXALLBWR W\F XUBGW\X\ZU Soi >RkV [kV DU^_UBGW\X\ZU Soi>]__CZGUREPA@SB^UBGW\X\ZU Soi>I>>>>FQ@AFZ>>>>I>VM]ZQ]_@BMXD	tsx{vuxgokkGWRkBYEVDGkUNk iUBGW\X\ZU Soi>]Rsx{vuxgokkGWRkCGC  VMVVk iVM]ZQ]_@BMXDHHsx{vuxgokkGWRkD@WYYENNCMMkkiVM]ZQ]_@BMXD
LR LWFQ@AFZ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiVM]ZQ]_@BMXDM MNEB\\BZFR		RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiVM]ZQ]_@BMXDMFkYLAQVWkNk		RUXGQFQ@AFZ>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiVM]ZQ]_@BMXDNWCUNEM 			RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiVM]ZQ]_@BMXDXSDQk^Y[_N[ UBGW\X\ZU Soi		RUXGQO>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@Nsx{vuxgokkGWRkQDZV_kiVM]ZQ]_@BMXD GELECSNPCCLEBQFG][ZkW[YDUFQGELECSNPCCLEoiXCDS]V]N]\U[DX CU_GSMD@VFQ@AFZ>]RMRFkUDFEFUZUBGW\X\ZU SoiVM]ZQ]_@BMXDO>[]\CNNBEZB[Q\APGU_GSMD@VU_GSMD@V>FQ@AFZ>>I>>>>]R^EQW_ZP\[\_^S^UBGW\X\ZU Soi^Y[_Z^BXM^YO>M^EGF^k]GM C[ZM UBGW\X\ZU SoiP[SC\_^CNZQR^SR@>SUB\XXALLBWR W\F XUBGW\X\ZU SoiL L>RkV [kV DU^_UBGW\X\ZU Soi>]__CZGUREPA@SB^UBGW\X\ZU Soi>I>FQ@AFZ>I>>>>W]XNFPD B ]	SL@D ]FAVZuvgdu`|U_GSMD@V>VM]ZQ]_@BMXD	sx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@NW]XNFPD B ]NWCUNEMVM]ZQ]_@BMXD>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iVM]ZQ]_@BMXDO>[]\CNNBEZB[Q\APGU_GSMD@VU_GSMD@V>FQ@AFZ>I>]Rtsx{vuxgokkGWRk_XXP] C^Mk iUBGW\X\ZU SoiFQ@AFZ>]RESXMZQG @W_B@LWXk U_GSMD@VO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UXSDQk^Y[_N[ >FQ@AFZ>I>]RMRFkUDFEFUZUBGW\X\ZU SoiVM]ZQ]_@BMXDO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ RS^]Q]]ZB@[U>FQ@AFZ>>>I>BNPPLF@kCX^GV[YFNZDRS^]Q]]ZB@[U >>FMFPU_Sk 	M MNEB\\BZFRhZU_GSMD@VUBGW\X\ZU SoiU_GSMD@VhZY@Z[D[XhZMFkYLAQVWkNk>]R^EQW_ZP\[\_^S^UBGW\X\ZU SoiSkBMPQQFSU VM]ZQ]_@BMXDFMFPU_Sk O>>]__CZGUREPA@SB^UBGW\X\ZU Soi>RkV [kV DU^_UBGW\X\ZU Soi>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGC[Q BXU [GD[EZLN>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>RAZW@][ZBBUkARVP\@R\FWS>O>@FMO>]RPQR]ZQPRS^]Q]]ZB@[U  FQ@AFZ>UBGW\X\ZU S	AQ_^@\LQBMLA[XS>^R]NCL[_kF^_XW	G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iUBGW\X\ZU SoiRUXGQZAXX>>>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U^R]NCL[_kF^_XWWCLB@]UGWCLB@]UGoi			XCDS]V]N]\U[DX CO>NBPNV]MXkNGGE	]Z@SQ@k[D@][ZRS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkNWYM^SkLZ[BNkiNBPNV]MXkNGGE FQ@AFZ>]R@XBCNVNEUBGW\X\ZU Soi		RUXGQO>tADPU@Qk[D@][ZRS^]Q]]ZB@[Usx{vuxgokkGWRkNWYM^SkLZ[BNkiRS^]Q]]ZB@[U>>>FQ@AFZ>I>>[]\CNNBEZB[Q\APGU_GSMD@V U_GSMD@V>>I>Rk[NLS^]	Z@SSV]@AXS]ZZY>>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^] HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]
L R VLVVHHM[YQk NNVYMFB\Rk[NLS^]FQ@AFZ>>ZBCG[R_L\	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UtSNQZW[PQRk[NLS^] Rk[NLS^]>]Rsx{vuxgokkGWRkCGC  VMVVk iZBCG[R_L\HHZBCG[R_L\			FQ@AFZ>]R^EQW_ZP\[\_^S^UBGW\X\ZU SoiRS^]Q]]ZB@[UXCDS]V]N]\U[DX Csx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]sx{vuxgokkGWRkV\W][LkiZBCG[R_L\tADPU@Qk[D@][ZYLW ^L@Nsx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Q BXU>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][Z[]GP BDWEMGA\NERk>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZRUXGQ>DMA@NR @SG	PQR]ZQPYLW ^L@Ntsx{vuxgokkGWRk\]XDEBSkWEkiuvgdu`|YLW ^L@Nuvgdu`|NWCUNEMkkr}xqkk>FQ@AFZsx{vuxgokkGWRkRAZRUMNSCGkiDMA@NR @SGG>I>RAZW@][ZAYAB LSXGWVRFMk]WA>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZ>]RPQR]ZQPYLW ^L@NFQ@AFZ>Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]FQ@AFZ>_QM	[]GP BDWEMGA\NERk>]R_QM			RUXGQFQ@AFZ>AY\ RN YGV[QQ	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMsx{vuxgokkGWRkBG_ RDRGAkiC[Q BXURk[NLS^]sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]>AMQACkQBCNU^	RS^]Q]]ZB@[Usx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]AY\ RN YGV[QQhZRk[NLS^]>ACZ]EAA _@CQA	sx{vuxgokkGWRkD@WYYENNCMMkkiAMQACkQBCNU^>VA^X[E	tsx{vuxgokkGWRkZZUG\R[XQk i_QMU>]RVA^X[EO>[kBASMZMLV	]Z@tsx{vuxgokkGWRkNL[k]B\kiVA^X[E>YDA@GLWN ]	tsx{vuxgokkGWRkWZFN RkiVA^X[E[kBASMZMLV>]Rsx{vuxgokkGWRkCGC  VMVVk iYDA@GLWN ]sx{vuxgokkGWRkUAU[DUV]kWkiYDA@GLWN ]Rk[NLS^]		RUXGQO>tsx{vuxgokkGWRkUD[ F_GkkE\kiVA^X[E>FQ@AFZ>>I>]R[kBASMZMLV
	ACZ]EAA _@CQAO>tsx{vuxgokkGWRkUD[ F_GkkE\kiVA^X[E>VA^X[E	tsx{vuxgokkGWRkZZUG\R[XQk i_QMC>>>]RVA^X[EO>tsx{vuxgokkGWRkWYQGGP^ kiVA^X[Esx{vuxgokkGWRk_^[RBMAFVAk iAMQACkQBCNU^[kBASMZMLVh>EW@DVSBFS\	tsx{vuxgokkGWRkWZFN RkiVA^X[EACZ]EAA _@CQA>tsx{vuxgokkGWRkUD[ F_GkkE\kiVA^X[E>>]REW@DVSBFS\		AMQACkQBCNU^[]\CNNBEZB[Q\APGU_GSMD@VRS^]Q]]ZB@[U>I>FQ@AFZ>IQXGQO>>>tsx{vuxgokkGWRk@PUGSFAkFkiVA^X[E>tsx{vuxgokkGWRkUD[ F_GkkE\kiVA^X[E>>>>I>I>[kBASMZMLV	ACZ]EAA _@CQA  >>>>VA^X[E	tsx{vuxgokkGWRkZZUG\R[XQk i_QMW[kBASMZMLV>>>>]RVA^X[EFQ@AFZ>tsx{vuxgokkGWRkWYQGGP^ kiVA^X[Esx{vuxgokkGWRk_^[RBMAFVAk iAMQACkQBCNU^[kBASMZMLVh>EW@DVSBFS\	tsx{vuxgokkGWRkWZFN RkiVA^X[EACZ]EAA _@CQA>]REW@DVSBFS\		AMQACkQBCNU^[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UC[Q BXU>tsx{vuxgokkGWRkUD[ F_GkkE\kiVA^X[E>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZSkBMPQQFSU WAFFQZ@FMFPU_Sk >O>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@HHWAFFQZ@			FQ@AFZC[Q BXU FMFPU_Sk hZ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiU_GSMD@VWAFFQZ@RXCPEVWDP^]P\dfqsk{rrgq`kwud`afqO>Q]@ SXWC@\R	RXCPEVWDP^]P\oioisx{vuxgokkGWRkD@WYYENNCMMkkiRXCPEVWDP^]P\oioi>@QU\V_]\_	sx{vuxgokkGWRkQDZV_kiWAFFQZ@Q]@ SXWC@\R>C\]XQsx{vuxgokkGWRkCGC  VMVVk i@QU\V_]\_sx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U@QU\V_]\_kPYO>>>Q]@ SXWC@\R	sx{vuxgokkGWRkD@WYYENNCMMkkikPYoi>@QU\V_]\_	sx{vuxgokkGWRkQDZV_kiWAFFQZ@Q]@ SXWC@\R >I>>FQ@AFZsx{vuxgokkGWRkQDZV_kiWAFFQZ@Q]@ SXWC@\RhZFMFPU_Sk hZsx{vuxgokkGWRkQDZV_kiWAFFQZ@Q]@ SXWC@\R>I>>>FQ@AFZNWCUNEMFMFPU_Sk hZ
hZWAFFQZ@>I>RAZW@][ZESXMZQG @W_B@LWXk _QM>>>>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUFQ@AFZ@FAQ>QGPF XFCLW]_	tSQ@k[D@][ZC[Q BXU_QM>]Rsx{vuxgokkGWRkCGC  VMVVk iQGPF XFCLW]_sx{vuxgokkGWRkUAU[DUV]kWkiQGPF XFCLW]_H		RUXGQO>LUkFX_AZZZFQ	sx{vuxgokkGWRkPF]F GWR@ZkiHQGPF XFCLW]_>]R]Z@LUkFX_AZZZFQoi			]Z@sx{vuxgokkGWRkNWYM^SkLZ[BNkiLQL]Z@LUkFX_AZZZFQoi
	jFQ@AFZRUXGQ>>>>I>>>FQ@AFZ@FAQ>>>I>>>>RAZW@][ZBNPPLF@kCX^GV[YFNZD_QM>O>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UHHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UFQ@AFZ>>>WSM\UWD_ADY	]Z@sx{vuxgokkGWRkNWYM^SkLZ[BNki >QGPF XFCLW]_	tSQ@k[D@][ZXSDQk^Y[_N[ _QM>>>ZFR GB^_Z	>]Rsx{vuxgokkGWRkCGC  VMVVk iQGPF XFCLW]_sx{vuxgokkGWRkUAU[DUV]kWkiQGPF XFCLW]_H		RUXGQO>LUkFX_AZZZFQ	sx{vuxgokkGWRkPF]F GWR@ZkiHQGPF XFCLW]_>]R]Z@LUkFX_AZZZFQoi			WSM\UWD_ADYZFR GB^_Z	]Z@LUkFX_AZZZFQoi>I>>ZFR GB^_Z>tADPU@Qk[D@][ZYLW ^L@N_QMWSM\UWD_ADYHZFR GB^_ZNWCUNEM>]RZFR GB^_Z
	[]\CNNBEZB[Q\APGU_GSMD@V C[Q BXU_QM>I>RAZW@][Z^k@VD ^UA]_LNM>>>>O>@FMO>]RPQR]ZQPRS^]Q]]ZB@[UFQ@AFZ>]RPQR]ZQPNWCUNEMHHtsx{vuxgokkGWRk_XXP] C^Mk icdkw{z`qz`kp}fHHQWY_NPDE^_Zcdkw{z`qz`kp}fFQ@AFZ>>>M YGAF^PE@ZQB	cdkw{z`qz`kp}f>>>@PD\^	M YGAF^PE@ZQBNWCUNEM>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[  >XDN^VABEUF	SL@D ]FAVZuvgdu`|NWCUNEM jC[Q BXU>L \DERMNRVW	GM_EAV^VFW>SASXkDk  _	SL@D ]FAVZuvgdu`|XSDQk^Y[_N[ >X\GNYLSN	sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ []GP BDWEMGA\NERkRUXGQ>>DEY[\]^XZF	X\GNYLSN		RUXGQsx{vuxgokkGWRk_kBSD@NAVkiX\GNYLSN>MPWC]SCD	]GGQ@sx{vuxgoNWCUNEMi
DFQR]Lsx{vuxgoNWCUNEMi
DFQR]LYLW ^L@N>\WXF^PSE	U_GSMD@Vsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkikMZ[W\L[YU[G@F]ZS^@U[FB_S@YGNYEL j >@GGQ\SRUZ\Y@	FG@C SM^kXMSMQR>C[Q BXU >UFFUMkkgxaskkkkn}dkzuyqkkkkg|y{dkqmkkkk{d`kzuyqkkkkcdkdfqr}lkkkksaufpkzuyqkkkkbqfg}{zkk>UFFUMkMZ[W\L[YU[XDN^VABEUFDEY[\]^XZFSASXkDk  _MPWC]SCD\WXF^PSEXCDS]V]N]\U[DX C>>]R@GGQ\SRUZ\Y@O>>>]R]Z@SQ@k[D@][ZXSDQk^Y[_N[ 
[]\CNNBEZB[Q\APGNWCUNEMU_GSMD@V>FQ@AFZ>>I>WAFFQZ@	tsx{vuxgokkGWRk\]XDEBSkWEki@PD\^tsx{vuxgokkGWRkBYEVDGkUNk i@PD\^>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGNWCUNEMU_GSMD@V>FQ@AFZ>>>>I>WAFFQZ@	^UNF\NZMLZLZkN[XAWAFFQZ@>NRU PPPEFXE	XCDS]V]N]\U[DX CSL@D ]FAVZuvgdu`|C[Q BXUj>M MNEB\\BZFR	U_GSMD@VNRU PPPEFXEYLW ^L@N >>MFkYLAQVWkNk	YLW ^L@NNRU PPPEFXEU_GSMD@V >]\]C]SGP 	SL@D ]FAVZuvgdu`|NWCUNEMLL>>G@NG]LVUS]WW	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ ]\]C]SGP U_GSMD@VWAFFQZ@>C^kGDE	sx{vuxgokkGWRkUAU[DUV]kWkiG@NG]LVUS]WWU_GSMD@V		RUXGQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@M MNEB\\BZFR		RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@MFkYLAQVWkNk		RUXGQC^kGDEO>A] LR\DNSRGW[[>FQ@AFZ>I>WAFFQZ@	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ G@NG]LVUS]WW>>>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGYLW ^L@NYLW ^L@N>FQ@AFZ>IO>WAFFQZ@	^UNF\NZMLZLZkN[XAWAFFQZ@>>>AX_ GWUEA	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@V @GGQ\SRUZ\Y@>>>\]^kNVZ\W	sx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@			>>>>]R\]^kNVZ\WO>]RESXMZQG @W_B@LWXk U_GSMD@VO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UYLW ^L@N>FQ@AFZ>I>]RMRFkUDFEFUZ@PD\^WAFFQZ@O>>>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UU_GSMD@V>FQ@AFZ>>>I>BNPPLF@kCX^GV[YFNZDXSDQk^Y[_N[ >IQXGQO>]RMRFkUDFEFUZ@PD\^O>[]\CNNBEZB[Q\APGNWCUNEMXSDQk^Y[_N[ >FQ@AFZ>I>>I>AX\PUMENN\	SkBMPQQFSU WAFFQZ@M MNEB\\BZFRhZAX_ GWUEAhZMFkYLAQVWkNk>]R^EQW_ZP\[\_^S^@PD\^AX\PUMENN\O>>FQ@AFZ>I>]__CZGUREPA@SB^@PD\^>>RkV [kV DU^_@PD\^>A] LR\DNSRGW[[>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZS_\_RA^UkAL\[^Y>O>@FMO>]RPQR]ZQPC[Q BXUFQ@AFZ>]RV@  NBWM[ML[CR^N]SFX^UDZ^SGFZFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZ>]Rsx{vuxgokkGWRkLEG\G\DMQADki			YLW ^L@NFQ@AFZ>]R]GGQ@kgqfbqfoU_GSMD@V iFQ@AFZ>]RSQ@k@FUZG]QZ@XSDQk^Y[_N[ FQ@AFZ>WFFWPDSN	GM_EAV^VFW>]Rtsx{vuxgokkGWRkY  PFNk iWFFWPDSNGEWVN@XUE@ P\\ZWFFWPDSN    @FAQ>]Rtsx{vuxgokkGWRkY  PFNk iWFFWPDSNHHtsx{vuxgokkGWRk_XXP] C^Mk iWFFWPDSNO>WFFWPDSN	uvgdu`|U_GSMD@V >]Rtsx{vuxgokkGWRk_XXP] C^Mk iWFFWPDSNWFFWPDSN	AEZGREWF[>I>PGCLC@XUP[Ck	SL@D ]FAVZuvgdu`|S>[MWU^^VR	C[Q BXUPGCLC@XUP[CkU_GSMD@V >>RAXkES FW	WFFWPDSN[MWU^^VR>EBkD VDQWQ	WFFWPDSNRS^]Q]]ZB@[UPGCLC@XUP[Ck>R[FQUW\UFFUMWFFWPDSNuvgdu`|U_GSMD@V AEZGREWF[UGVQYD[EDMYXCO>MQGUWDGRVV[	VQYD[EDMYXCNWCUNEMPGCLC@XUP[Ck>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiMQGUWDGRVV[O>>VZ@AUCVNLYX	]Z@tsx{vuxgokkGWRkUMX_NCYCkiMQGUWDGRVV[>>>>]RVZ@AUCVNLYX	sx{vuxgokkGWRkNWYM^SkLZ[BNkiLPLPHHVZ@AUCVNLYX
sx{vuxgokkGWRkNWYM^SkLZ[BNki O>UC[WM Z MQGUWDGRVV[>W[Z@]ZAQ>I>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiVQYD[EDMYXCYLW ^L@NPGCLC@XUP[CkXSDQk^Y[_N[  FQ@AFZ>UC[WM Z MQGUWDGRVV[>I>I>AZGQ@VQYD[EDMYXCMQGUWDGRVV[VZ@AUCVNLYX>>S^\@WF@YSMS	uvgdu`|RS^]Q]]ZB@[U[MWU^^VR>>]RWFFWPDSN		uvgdu`|XSDQk^Y[_N[  tsx{vuxgokkGWRk@Y@R NPPDCC@kiS^\@WF@YSMSZ]ELLM]_XSBWGQS^\@WF@YSMS		RUXGQO>SUB\XXALLBWR W\F XS^\@WF@YSMS>]RUC[WM Z S^\@WF@YSMSsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ t[DWUW\Qk]ZBUX]PU@QS^\@WF@YSMS@FAQ>I>>>>AZGQ@S^\@WF@YSMS>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiEBkD VDQWQ]Z@tsx{vuxgokkGWRkUMX_NCYCkiEBkD VDQWQ
sx{vuxgokkGWRkNWYM^SkLZ[BNkiFQ@AFZ>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRAXkES FWsx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@tR]XQW@]YQRAXkES FW FQ@AFZ>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRAXkES FWO>CG_S^QS[	tsx{vuxgokkGWRk@Y@R NPPDCC@kiWFFWPDSNRS^]Q]]ZB@[UPGCLC@XUP[Cksx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iWFFWPDSNC[Q BXUPGCLC@XUP[Ck>]RCG_S^QS[		sx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXUCG_S^QS[BQFG][ZkW[YDUFQCG_S^QS[XCDS]V]N]\U[DX C
FQ@AFZ>AZGQ@CG_S^QS[>I>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRAXkES FWO>WNBPQFSRC	WFFWPDSNNWCUNEMSL@D ]FAVZuvgdu`|SLL>>Z_@_M]ELL	tsx{vuxgokkGWRk@Y@R NPPDCC@kiWNBPQFSRCG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iWNBPQFSRC>CW]k[VZVD_	>]RZ_@_M]ELL		O>XE_BAVB[@	sx{vuxgokkGWRkPF]F GWR@ZkiHZ_@_M]ELL>>>>CW]k[VZVD_	]Z@XE_BAVB[@oi>I>>>>]RCW]k[VZVD_
sx{vuxgokkGWRkNWYM^SkLZ[BNkiCW]k[VZVD_
[]\CNNBEZB[Q\APGC[Q BXUYLW ^L@N>QXGQ]RCW]k[VZVD_			sx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@tR]XQW@]YQRAXkES FW
[]\CNNBEZB[Q\APGNWCUNEMC[Q BXU>AZGQ@WNBPQFSRCZ_@_M]ELLXE_BAVB[@CW]k[VZVD_>I>Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]  FQ@AFZ>PD[N @ZNSE	WU^YMASDXk_GG>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZU_GSMD@V >ULLQ]SRVEM	AEZGREWF[YLW ^L@N >LDVEEMDS@@^LE]R	tsx{vuxgokkGWRk_XXP] C^Mk iULLQ]SRVEM>ULLQ]SRVEMkMZ[W\L[YU[NWCUNEM >AEZGREWF[NWCUNEMkMZ[W\L[YU[kMZ[W\L[YU[RS^]Q]]ZB@[U>>BGSY[k	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[Usx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxk|{g`]GGQ@kgqfbqfoYLW ^L@NikgqfbqfoU_GSMD@Vi>CN]_AF N	PQR]ZQPXSDQk^Y[_N[ cdyakdxas}zkp}fcdyakdxas}zkp}fAEZGREWF[RS^]Q]]ZB@[U >@kLU\UXNQQLSD	PQR]ZQPXSDQk^Y[_N[ cdkdxas}zkp}fcdkdxas}zkp}fAEZGREWF[NWCUNEM>PkR\NVY@G \	PQR]ZQPNWCUNEMcdkw{z`qz`kp}fAEZGREWF[>WM_kR[^ @QNQ	FG@C SM^kXMSMQR>XSDQk^Y[_N[ >>UFFUMkkdu`|kv kkkkdxas}zkvugq kkkkp{yu}zkkkk|vkv kkkksdu`|kv kkkkuvgdu`|kv kkkkw{z`qz`p}fkv kkkkyap}fkv kkkkdxas}zp}fkv kkkkgxaskkkkbqfg}{zkk>>>UFFUMsx{vuxgokkGWRkV\W][LkiLDVEEMDS@@^LE]RPD[N @ZNSEBGSY[ksx{vuxgokkGWRkV\W][LkiEBkD VDQWQsx{vuxgokkGWRkV\W][LkiRAXkES FWsx{vuxgokkGWRkV\W][Lkiuvgdu`|sx{vuxgokkGWRkV\W][LkiPkR\NVY@G \sx{vuxgokkGWRkV\W][LkiCN]_AF Nsx{vuxgokkGWRkV\W][Lki@kLU\UXNQQLSDsx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZNWCUNEMXCDS]V]N]\U[DX C>>]RWM_kR[^ @QNQO>]R]Z@SQ@k[D@][ZRS^]Q]]ZB@[U
[]\CNNBEZB[Q\APGNWCUNEMNWCUNEM>FQ@AFZ>I>]RM[YQk NNVYMFB\WM_kR[^ @QNQO>[]\CNNBEZB[Q\APGU_GSMD@VU_GSMD@V >FQ@AFZ>I>]R^EQW_ZP\[\_^S^RAXkES FWWM_kR[^ @QNQO>M^EGF^k]GM C[ZM RAXkES FWP[SC\_^CNZQR^SR@>SUB\XXALLBWR W\F XRAXkES FW>RkV [kV DU^_RAXkES FW>_ W^\V CPNY_WFFWPDSNU_GSMD@VPGCLC@XUP[Cksx{vuxgokkGWRkk[AFM@ZWUECkiWM_kR[^ @QNQXSDQk^Y[_N[ >_ W^\V CPNY_WFFWPDSNRS^]Q]]ZB@[UPGCLC@XUP[CkXCDS]V]N]\U[DX CYLW ^L@N>t]ZWXAPQk[ZWQRAXkES FW>GQ@k@FUZG]QZ@NWCUNEM >I>AZGQ@CN]_AF N@kLU\UXNQQLSDPkR\NVY@G \>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZXABG]WV@AL\RR_QCDM^ @W>O>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @WFQ@AFZRUXGQ>>L_CWV	sx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W>]RL_CWV
  FQ@AFZ@FAQ>>>>]RL_CWV  FQ@AFZRUXGQ>QZQ[DQ^QMG[ED	sx{vuxgokkGWRkQDZV_kiRR_QCDM^ @W >CPU\RGB\^CkP	sx{vuxgokkGWRk\]]Y]EQPVkiQZQ[DQ^QMG[EDsx{vuxgokkGWRk\]]Y]EQPVkiQZQ[DQ^QMG[EDh@>FQ@AFZCPU\RGB\^CkPsx{vuxgokkGWRkD@WYYENNCMMkkiQZQ[DQ^QMG[ED
>I>RAZW@][ZZ@SSV]@AXS]ZZYE_W]PXN	RUXGQ>O>>>>G@U@]WRk[NLS^]	ZAXX>]RE_W]PXNO>Rk[NLS^]	ZAXX>>>I>]RRk[NLS^]		ZAXXFQ@AFZRk[NLS^]>RR_QCDM^ @W	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @Wsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W
 sx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W	  XABG]WV@AL\RR_QCDM^ @WM[YQk NNVYMFB\RR_QCDM^ @WO>>Rk[NLS^]	RR_QCDM^ @W>FQ@AFZRk[NLS^]>I>_k@ULGUF	M_E@QREC][RS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkCGC  VMVVk i_k@ULGUFsx{vuxgokkGWRkD@WYYENNCMMkki_k@ULGUF
 sx{vuxgokkGWRkD@WYYENNCMMkki_k@ULGUF	   XABG]WV@AL\_k@ULGUFM[YQk NNVYMFB\_k@ULGUFO>Rk[NLS^]	_k@ULGUF>FQ@AFZRk[NLS^]>I>Rk[NLS^]	RUXGQ>FQ@AFZRk[NLS^]>I>>>>RAZW@][ZWU^YMASDXk_GGE_W]PXN	RUXGQ>>>>O>>>>G@U@]WBZ^GEBSkk\D^	ZAXX>>]RE_W]PXNO>BZ^GEBSkk\D^	ZAXX>I>]RBZ^GEBSkk\D^		ZAXXFQ@AFZBZ^GEBSkk\D^>RR_QCDM^ @W	Z@SSV]@AXS]ZZY>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @WHHsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W HHsx{vuxgokkGWRkD@WYYENNCMMkkiRR_QCDM^ @W
 HHXABG]WV@AL\RR_QCDM^ @WHHM[YQk NNVYMFB\RR_QCDM^ @WO>BZ^GEBSkk\D^	RUXGQ>FQ@AFZBZ^GEBSkk\D^>I>>>>BZ^GEBSkk\D^	sx{vuxgokkGWRkV\W][LkiF[GDUDUYA_[_^kQARR_QCDM^ @W>FQ@AFZBZ^GEBSkk\D^>>>>I>RAZW@][ZS]^CLWANUZ^FX@FL[Mk_Q^>O>]Rsx{vuxgokkGWRkCGC  VMVVk i^FX@FL[Mk_Q^HHsx{vuxgokkGWRkD@WYYENNCMMkki^FX@FL[Mk_Q^j HHsx{vuxgokkGWRkQDZV_ki^FX@FL[Mk_Q^		hLRhLVFQ@AFZ>>>CAEL_]RYEF	tsx{vuxgokkGWRk[RP^kXQF \[Ekibsx{vuxgokkGWRkQDZV_ki^FX@FL[Mk_Q^LL>CAEL_]RYEF	sx{vuxgokkGWRkWBSB\_k iCAEL_]RYEFCAEL_]RYEFoi>]RCAEL_]RYEF HHCAEL_]RYEF
  FQ@AFZCAEL_]RYEF>>FQ@AFZ>I>RAZW@][ZB\B[_D_kRG_VSFL]]WCLB@]UG>O>FQ@AFZsx{vuxgokkGWRkYWPCDD@Uki\QLPQWWCLB@]UGoi>>>I>RAZW@][ZMV\Yk_]LXPMNENDELUZDQD^Z\B>O>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHNENDELUZDQD^Z\B			FQ@AFZNENDELUZDQD^Z\B>G@U@]WLCC_P	ZAXX>]RLCC_P			ZAXXO>>>LCC_P	RUXGQ>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM O>kPP	PQR]ZQPYLW ^L@Ncdkw{z`qz`kp}fPQR]ZQPYLW ^L@N uvgdu`|>]RkPP		O>YGR@MYGWCC	tP]G_kRFQQkGDUWQkPP>]RYGR@MYGWCC		RUXGQYGR@MYGWCC
	LCC_P	@FAQ>>I>I>]RLCC_PO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU tADPU@Qk[D@][ZC[Q BXU sx{vuxgokkGWRkNWYM^SkLZ[BNkiYLW ^L@N>>>IQXGQ]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[   O>L[Pk[QSSGL	]Z@SQ@k[D@][ZXSDQk^Y[_N[  >>]RL[Pk[QSSGLsx{vuxgokkGWRkNWYM^SkLZ[BNkiL[Pk[QSSGLLCC_P	RUXGQ>>>>I>I>]RLCC_PO>>>FQ@AFZNENDELUZDQD^Z\B>I>WPE^^L^V[^AA	Q@E@_U]k]]E@PAQY>]RWPE^^L^V[^AA			HHWPE^^L^V[^AA
	LRVVVL PR O>>>[C[ALERkB	 sx{vuxgokkGWRkLFUXCD_ k i>IQXGQ]RWPE^^L^V[^AA
	O>[C[ALERkB	  sx{vuxgokkGWRkLFUXCD_ k i >IQXGQO>FQ@AFZNENDELUZDQD^Z\B>>I>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\B
	[C[ALERkBFQ@AFZNENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkDMF\VYFZMkiNENDELUZDQD^Z\B			RS^]Q]]ZB@[U FQ@AFZNENDELUZDQD^Z\B>C\]XQsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\B[C[ALERkB  O>]MC[kQAAGC	>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V O>@FMO>]MC[kQAAGC	tsx{vuxgokkGWRkMUSkNX_R_Dk iFUZP[YkVM@QG>>>IWU@W\`\F[CUVXQ[GD[EZLNO>]MC[kQAAGC	>IWU@W\qLWQD@][Z[GD[EZLNO>]MC[kQAAGC	>I>I>>>]Rsx{vuxgokkGWRkD@WYYENNCMMkki]MC[kQAAGC O>]MC[kQAAGC	sx{vuxgokkGWRkk[AFM@ZWUECkiAZ]E]P@FAQ>>>>C\]XQsx{vuxgokkGWRkD@WYYENNCMMkki]MC[kQAAGC]MC[kQAAGC	sx{vuxgokkGWRkk[AFM@ZWUECki]MC[kQAAGC>I>NENDELUZDQD^Z\B	hZ]MC[kQAAGCYLW ^L@N >I>>FQ@AFZNENDELUZDQD^Z\B>I>>RAZW@][Z^UNF\NZMLZLZkN[XANENDELUZDQD^Z\B>O>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\B	 FQ@AFZNENDELUZDQD^Z\B>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXU NENDELUZDQD^Z\B>FQ@AFZsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZZFR GB^_ZNENDELUZDQD^Z\B>>>>I>RAZW@][ZQ@E@_U]k]]E@PAQY>O>G@U@]WW_^PAWE_LF	ZAXX>>>>]RW_^PAWE_LF		ZAXXFQ@AFZW_^PAWE_LF>W_^PAWE_LF	>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NFQ@AFZW_^PAWE_LF>^FX@FL[Mk_Q^	tsx{vuxgokkGWRkQZNVM]LkiXSDQk^Y[_N[ >]Rsx{vuxgokkGWRkCGC  VMVVk i^FX@FL[Mk_Q^FQ@AFZW_^PAWE_LF>^FX@FL[Mk_Q^	sx{vuxgokkGWRk\G[ML]GWki^FX@FL[Mk_Q^>]R^FX@FL[Mk_Q^			FQ@AFZW_^PAWE_LF>]R^FX@FL[Mk_Q^			C[Q BXUO>W_^PAWE_LF	>FQ@AFZW_^PAWE_LF>>I>QGPF XFCLW]_	RX[U@^FX@FL[Mk_Q^>>>>]RAXEZFV	sx{vuxgokkGWRkEFkADDkisx{vuxgokkGWRkQDZV_ki^FX@FL[Mk_Q^>]R]RAXEZFV			sQGPF XFCLW]_	    >>QXGQ]R]RAXEZFV			yQGPF XFCLW]_	 >QXGQ]R]RAXEZFV			QGPF XFCLW]_	>]RQGPF XFCLW]_
W_^PAWE_LF	]Z@QGPF XFCLW]_>FQ@AFZW_^PAWE_LF>I>>>>RAZW@][Z^RSDR NMZ]@D[kBASMZMLV>O>[kBASMZMLV	]Z@[kBASMZMLV>]R[kBASMZMLV	FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZRUXGQ>^GWFQS\L	Q@E@_U]k]]E@PAQY>]R^GWFQS\L			FQ@AFZ@FAQ>]R^GWFQS\L	FQ@AFZRUXGQ>VRSFPMLQ@LYX	tYQY[FMkSQ@kAGUSQ@FAQ>>>]Rsx{vuxgokkGWRkDCX^kkiVRSFPMLQ@LYXHHVRSFPMLQ@LYXFQ@AFZRUXGQ>FQ@AFZ^GWFQS\LVRSFPMLQ@LYX
[kBASMZMLVLULP>I>>>RAZW@][ZMRM QRSUkX N M[kBASMZMLV>O>[kBASMZMLV	]Z@[kBASMZMLV>]R[kBASMZMLV	FQ@AFZRUXGQ>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZ@FAQ>^GWFQS\L	Q@E@_U]k]]E@PAQY>]R^GWFQS\L			FQ@AFZ@FAQ>]R^GWFQS\L	FQ@AFZ@FAQ>>VRSFPMLQ@LYX	tYQY[FMkSQ@kAGUSQ@FAQ>]Rsx{vuxgokkGWRkDCX^kkiVRSFPMLQ@LYXHHVRSFPMLQ@LYXFQ@AFZ@FAQ>FQ@AFZ^GWFQS\LVRSFPMLQ@LYX
[kBASMZMLVj >I>RAZW@][ZSFFMRN]XGWQNDCPZkSGSNUN>>>>O>]Rsx{vuxgokkGWRkCGC  VMVVk iDCPZkSGSNUNHHDCPZkSGSNUN			HHtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtWXQUFG@U@WUW\Q@FAQDCPZkSGSNUN>[kBASMZMLV	tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN>]Rsx{vuxgokkGWRkDCX^kki[kBASMZMLVHH[kBASMZMLVFQ@AFZRUXGQ>]R[kBASMZMLV
 FQ@AFZZAXX>]R[kBASMZMLV
   ^RSDR NMZ]@D[kBASMZMLVFQ@AFZZAXX>>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXX[kBASMZMLV>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\B		[kBASMZMLVFQ@AFZRUXGQ>FQ@AFZ[kBASMZMLV
LRWLWP^UNF\NZMLZLZkN[XANENDELUZDQD^Z\BNENDELUZDQD^Z\B>I>RAZW@][ZRkV [kV DU^_DCPZkSGSNUN>>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM  HHsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N FQ@AFZ>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iDCPZkSGSNUNHHDCPZkSGSNUN			HHtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNFQ@AFZ>]R]GGQ@sx{vuxgoU_GSMD@ViHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoRS^]Q]]ZB@[U iO>sx{vuxgoXSDQk^Y[_N[  i	SQ@k[D@][ZNWCUNEMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k isx{vuxgoRS^]Q]]ZB@[Uisx{vuxgoXSDQk^Y[_N[ i	UFFUM>I>WCLB@]UG	sx{vuxgoC[Q BXUi>NENDELUZDQD^Z\B	SFFMRN]XGWQNDCPZkSGSNUN>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BFQ@AFZ>WCLB@]UGosx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUNi	UFFUMD	
DCPZkSGSNUN\	
sx{vuxgokkGWRkk[AFM@ZWUECkiNENDELUZDQD^Z\BS	
XCDS]V]N]\U[DX C@	
sx{vuxgokkGWRkNWYM^SkLZ[BNki>]Rsx{vuxgokkGWRkEMVLY\AkiWCLB@]UG
O>R[FQUW\WCLB@]UGUGCPF]\AUC	
QGPF XFCLW]_O>]Rsx{vuxgokkGWRkWBSB\_k iQGPF XFCLW]_HH]GGQ@QGPF XFCLW]_o@iHH]Z@QGPF XFCLW]_o@isx{vuxgokkGWRkNWYM^SkLZ[BNki AZGQ@WCLB@]UGoCPF]\AUCi>I>>C\]XQsx{vuxgokkGWRkEMVLY\AkiWCLB@]UG
 O>>>BSDGBS_YADM	ZAXX>XEZZkEMRLB	ZAXX>>>R[FQUW\WCLB@]UGUGCPF]\AUC	
QGPF XFCLW]_O>[XPkFZV	sx{vuxgokkGWRkWBSB\_k iQGPF XFCLW]_]GGQ@QGPF XFCLW]_o@i]Z@QGPF XFCLW]_o@i>]RXEZZkEMRLB			ZAXXHH[XPkFZVXEZZkEMRLBO>>>XEZZkEMRLB	[XPkFZV>BSDGBS_YADM	CPF]\AUC>>I>I>]RBSDGBS_YADM			ZAXXVFQU_>AZGQ@WCLB@]UGoBSDGBS_YADMi>I>I>ADPU@Qk[D@][ZXSDQk^Y[_N[ WCLB@]UGYLW ^L@N>sx{vuxgoXSDQk^Y[_N[ i	WCLB@]UG>>>I>RAZW@][ZZ]ELLM]_XSBWGQDCPZkSGSNUN>>O>>]Rsx{vuxgokkGWRkCGC  VMVVk iDCPZkSGSNUNHHDCPZkSGSNUN			FQ@AFZRUXGQ>]R]GGQ@sx{vuxgoC[Q BXUiHHsx{vuxgokkGWRkWBSB\_k isx{vuxgoC[Q BXUiO>sx{vuxgoRS^]Q]]ZB@[Ui	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM  SQ@k[D@][ZRS^]Q]]ZB@[UUFFUMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k isx{vuxgoYLW ^L@Nisx{vuxgoC[Q BXUi	UFFUM>I>WCLB@]UG	sx{vuxgoNWCUNEMi>>>>WDWFFGG	sx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUN>>>>]R]GGQ@WCLB@]UGoWDWFFGGisx{vuxgokkGWRkWBSB\_k iWCLB@]UGoWDWFFGGi]GGQ@WCLB@]UGoWDWFFGGio\iO>>>]R]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN
LQPLVFQ@AFZNWCUNEM>NENDELUZDQD^Z\B	SFFMRN]XGWQNDCPZkSGSNUN>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BO>FQ@AFZsx{vuxgokkGWRkk[AFM@ZWUECkiNENDELUZDQD^Z\B			WCLB@]UGoWDWFFGGio\i@FAQRS^]Q]]ZB@[U>I>FQ@AFZRUXGQ>I>]RkACM_XP_VCUZ YkLDCPZkSGSNUN O>YMN[U\CB@ RCGX	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXX >]Rsx{vuxgokkGWRkCGC  VMVVk iYMN[U\CB@ RCGXsx{vuxgokkGWRkUAU[DUV]kWkiYMN[U\CB@ RCGXU_GSMD@V 		RUXGQFQ@AFZC[Q BXU >I>FQ@AFZRUXGQ>I>>RAZW@][Z^_ZDNBXYV>O>G@U@]WWCLB@]UG	ZAXX>]RWCLB@]UG		ZAXXFQ@AFZWCLB@]UG>NENDELUZDQD^Z\B	SFFMRN]XGWQNR^N]SFX^UDZ^SGFZ>WCLB@]UG	sx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BNENDELUZDQD^Z\B		sx{vuxgokkGWRkk[AFM@ZWUECkiNENDELUZDQD^Z\B>FQ@AFZWCLB@]UG>I>RAZW@][ZCQ_kMFZM^Y^]NLYB>O>>>FQ@AFZsx{vuxgokkGWRkQDZV_ki^_ZDNBXYV>I>RAZW@][ZE@NWDQ_Q]^XZX]C>O>FQ@AFZGM_EAV^VFWU_GSMD@VSL@D ]FAVZuvgdu`|NWCUNEM  YLW ^L@N>I>RAZW@][ZSSLFDW@VYW[X]BXX>>>>O>NFASMYY^LU[	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM  O>[QRRY _	tSQ@k[D@][ZXSDQk^Y[_N[ UFFUM>>>]Rsx{vuxgokkGWRkWBSB\_k i[QRRY _NFASMYY^LU[	[QRRY _>I>NENDELUZDQD^Z\B	tsx{vuxgokkGWRk@Y@R NPPDCC@kiE@NWDQ_Q]^XZX]Ctsx{vuxgokkGWRkBYEVDGkUNk iE@NWDQ_Q]^XZX]C>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\Bsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BU_GSMD@V			O>ZULN Z] [@E	sx{vuxgokkGWRkWL[M\VYkisx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\B @FAQ>]Rsx{vuxgokkGWRkWBSB\_k iZULN Z] [@EQYD@MNFASMYY^LU[oU_GSMD@ViHHQYD@MZULN Z] [@EoRS^]Q]]ZB@[UiZULN Z] [@EoYLW ^L@Ni
	NFASMYY^LU[oYLW ^L@NiNFASMYY^LU[	ZULN Z] [@E>I>>>FQ@AFZNFASMYY^LU[>I>>>>RAZW@][ZZ^kkDCPSE^ CUk@C\Z^B]QB>O>>>@FMO>]RPQR]ZQPYLW ^L@N FQ@AFZ>[PBCS@XBRQR	sx{vuxgokkGWRkNWYM^SkLZ[BNki>]R@C\Z^B]QB			C[Q BXUHH@C\Z^B]QB			XSDQk^Y[_N[ O>>>DFQB	SSLFDW@VYW[X]BXX>>>]R>]GGQ@DFQBoYLW ^L@NiDFQBoC[Q BXUiDFQBoYLW ^L@Ni			@C\Z^B]QB>>>[PBCS@XBRQR]Z@DFQBoC[Q BXUi@C\Z^B]QB			XSDQk^Y[_N[  LL>FQ@AFZ>I>NFASMYY^LU[	UFFUM>B	
XCDS]V]N]\U[DX C>RS^]Q]]ZB@[U	
CQ_kMFZM^Y^]NLYB>XSDQk^Y[_N[ 	
R^N]SFX^UDZ^SGFZ>RS^]Q]]ZB@[U	
sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N>>>>U_GSMD@V 	
@C\Z^B]QB>>>>RS^]Q]]ZB@[U	
[PBCS@XBRQR>YLW ^L@N	
[PBCS@XBRQR>>>>NWCUNEM	
]GGQ@kgqfbqfoU_GSMD@Vi]Z@kgqfbqfoXSDQk^Y[_N[ i[PBCS@XBRQR>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>WG_RQ]YSWU	tADPU@Qk[D@][ZC[Q BXUNFASMYY^LU[YLW ^L@N>>>]RWG_RQ]YSWU			RUXGQsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  O>kAkZXAR	tSQ@k[D@][ZRS^]Q]]ZB@[UUFFUM>P_UYYGQPX^^	sx{vuxgokkGWRkWBSB\_k ikAkZXARHH]GGQ@kAkZXARoU_GSMD@VikAkZXARoYLW ^L@NiHHkAkZXARoNWCUNEMi		@C\Z^B]QBHH]Z@kAkZXARoNWCUNEMi		[PBCS@XBRQR>]RP_UYYGQPX^^]GGQ@sx{vuxgoNWCUNEMisx{vuxgokkGWRk@L\SQY@ZAkisx{vuxgoYLW ^L@Nisx{vuxgokkGWRkUU\RUWEQkisx{vuxgoU_GSMD@ViU_GSMD@VO>tsx{vuxgoYLW ^L@Ni
W\QW_kW[ZZQW@][ZRUXGQ>tADPU@Qk[D@][ZU_GSMD@VNFASMYY^LU[NWCUNEM>I>AZGQ@kAkZXARP_UYYGQPX^^>>>I>AZGQ@WG_RQ]YSWU>I>PLDRFkX ]D]@Y]	GM_EAV^VFW>>]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]HHGEWVN@XUE@ P\\ZPLDRFkX ]D]@Y] @FAQO>tsx{vuxgokkGWRk_GUYNZVVVk iE@NWDQ_Q]^XZX]CYLW ^L@Nsx{vuxgokkGWRkPDZXFZEVS\SkiNFASMYY^LU[>I>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][Z^ABU@ML^PF^MWNFASMYY^LU[>O>]Rsx{vuxgokkGWRkWBSB\_k iNFASMYY^LU[HHQYD@MNFASMYY^LU[oXSDQk^Y[_N[ iHHsx{vuxgokkGWRkCGC  VMVVk iNFASMYY^LU[oRS^]Q]]ZB@[UiFQ@AFZC[Q BXU>LUkFX_AZZZFQ	NFASMYY^LU[oU_GSMD@V i>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQHH]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiLUkFX_AZZZFQL VLUFQ@AFZC[Q BXU>]RZk RVYS[@^S WQSALUkFX_AZZZFQFQ@AFZC[Q BXU>AQVCCEY@	]GGQ@NFASMYY^LU[oXSDQk^Y[_N[ iNFASMYY^LU[oRS^]Q]]ZB@[Ui>NkBUEUP@LF	]GGQ@NFASMYY^LU[oC[Q BXUi]Z@NFASMYY^LU[oXSDQk^Y[_N[ i>]RAQVCCEY@			RS^]Q]]ZB@[UFQ@AFZNkBUEUP@LF
sx{vuxgokkGWRkNWYM^SkLZ[BNkiNkBUEUP@LF	NWCUNEMYLW ^L@N>>>>]RAQVCCEY@			YLW ^L@NFQ@AFZXSDQk^Y[_N[ >>>>]RAQVCCEY@			NWCUNEMFQ@AFZNkBUEUP@LF
sx{vuxgokkGWRkNWYM^SkLZ[BNkiNkBUEUP@LF	LLU_GSMD@VU_GSMD@V>FQ@AFZNWCUNEM>>>I>RAZW@][Z@R[P][SEWQZV\PDCPZkSGSNUN>O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNFQ@AFZRUXGQ>PGA_N 	]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiDCPZkSGSNUN>>]RPGA_N   HHPGA_N 
   FQ@AFZRUXGQ>YMN[U\CB@ RCGX	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXX>]Rsx{vuxgokkGWRkCGC  VMVVk iYMN[U\CB@ RCGXHHsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[UYMN[U\CB@ RCGXFQ@AFZRUXGQ>>>]RPGA_N 
LPVRQVL O>[C[ALERkB	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUNRUXGQZAXXPGA_N >FQ@AFZsx{vuxgokkGWRkCGC  VMVVk i[C[ALERkBsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U[C[ALERkB			>I>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BFQ@AFZRUXGQ>FQ@AFZM[YQk NNVYMFB\NENDELUZDQD^Z\B>I>RAZW@][ZGW\A]MX]PXDSN E RBZXG_QLkAW@D\UBA>O>@WDGAPZ	tsx{vuxgokkGWRkBYEVDGkUNk iN E RBZRUXGQZAXXLQLW>FXM@Zk]QNDFR	tsx{vuxgokkGWRkBYEVDGkUNk iXG_QLkAW@D\UBARUXGQZAXXLULV>]Rsx{vuxgokkGWRkCGC  VMVVk i@WDGAPZHHsx{vuxgokkGWRkCGC  VMVVk iFXM@Zk]QNDFRFQ@AFZRUXGQ>CZkZPNUUSkSU	FRVLLkS^W	ZAXX>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRAZW@][ZkQL]G@GhounUNkih@WDGAPZQBS\R\]WUCZkZPNUUSkSU	QBS\R\]WUoi>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRAZW@][ZkQL]G@GhounUNkihFXM@Zk]QNDFRQBS\R\]WUFRVLLkS^W	QBS\R\]WUoi>>>>FQ@AFZCZkZPNUUSkSU		ZAXXCZkZPNUUSkSU			FRVLLkS^W>I>RAZW@][ZZk RVYS[@^S WQSADCPZkSGSNUN>O>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiDCPZkSGSNUNU_GSMD@V>R[FQUW\UFFUMsx{vuxgokkGWRkWLGRkXNMY[kiDCPZkSGSNUNVZ[[SF]P]DGWUAZUGAYP BG^ BO>@YRWFGQ_QR^^] 	AYP BG^ BU_GSMD@VkMZ[W\L[YU[>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@YRWFGQ_QR^^] HH]Z@tsx{vuxgokkGWRkUMX_NCYCki@YRWFGQ_QR^^] sx{vuxgokkGWRkNWYM^SkLZ[BNki  W[Z@]ZAQ>>_NMB^VSW	sx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk i@YRWFGQ_QR^^] >]R_NMB^VSW			W[Z@]ZAQ>NENDELUZDQD^Z\B	SFFMRN]XGWQNDCPZkSGSNUN>]RNENDELUZDQD^Z\B			ZAXXW[Z@]ZAQ>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BNENDELUZDQD^Z\B		sx{vuxgokkGWRkk[AFM@ZWUECkiNENDELUZDQD^Z\B			_NMB^VSWFQ@AFZ@FAQ>I>>>>FQ@AFZRUXGQ>I>RAZW@][ZUGPBCFYDGYFM [DCPZkSGSNUN>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU HHsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V FQ@AFZ>W_^PAWE_LF	tSQ@k[D@][ZNWCUNEMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iW_^PAWE_LFW_^PAWE_LF	UFFUM>>>W_^PAWE_LFosx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUNi	DCPZkSGSNUN>>>>]Rsx{vuxgokkGWRkEMVLY\AkiW_^PAWE_LF
 W_^PAWE_LF	sx{vuxgokkGWRkXY\ECNkLB^@kiW_^PAWE_LFjZAXX@FAQ>tADPU@Qk[D@][ZXSDQk^Y[_N[ W_^PAWE_LFXSDQk^Y[_N[ >I>RAZW@][ZkkVPPRE]]AQ>O>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U HHsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VFQ@AFZ>>>W_^PAWE_LF	tSQ@k[D@][ZU_GSMD@VUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iW_^PAWE_LFHHQYD@MW_^PAWE_LFFQ@AFZ>MUEGS@Ak	UFFUM>R[FQUW\W_^PAWE_LFUGCPF]\AUC	
LUkFX_AZZZFQO>]Rsx{vuxgokkGWRkCGC  VMVVk iLUkFX_AZZZFQHHLUkFX_AZZZFQ			HHtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQW[Z@]ZAQ>]RLUkFX_AZZZFQ			R^N]SFX^UDZ^SGFZW[Z@]ZAQ>RNkRVF_EEQLPSk	tsx{vuxgokkGWRkC]YQRGZkiLUkFX_AZZZFQ>S_B ^VM	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk iRNkRVF_EEQLPSksx{vuxgokkGWRkCGC  VMVVk iS_B ^VMRNkRVF_EEQLPSk			S_B ^VMW[Z@]ZAQ>AZGQ@RNkRVF_EEQLPSkS_B ^VM>]RZ]ELLM]_XSBWGQLUkFX_AZZZFQ			RUXGQO>MUEGS@AkoCPF]\AUCi	LUkFX_AZZZFQ>W[Z@]ZAQ>I>SUB\XXALLBWR W\F XLUkFX_AZZZFQ >]RUC[WM Z LUkFX_AZZZFQO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[DWUW\Qk]ZBUX]PU@QLUkFX_AZZZFQ@FAQ>IQXGQ]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQO>>MUEGS@AkoCPF]\AUCi	LUkFX_AZZZFQ>I>I>tADPU@Qk[D@][ZNWCUNEMMUEGS@AkYLW ^L@N>>>>I>RAZW@][Z\^LXZN@@]Zk[C@U>O>@FMO>>>>[GD[EZLN	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtQFF[FkSQ@kXUG@ZAXX>]R>>>>sx{vuxgokkGWRkWBSB\_k i[GD[EZLNQYD@M[GD[EZLNoXSDQk^Y[_N[ iQYD@M[GD[EZLNoXSDQk^Y[_N[ i>sx{vuxgokkGWRkUFBG[ZLZN Gk i[GD[EZLNoXSDQk^Y[_N[  iUFFUMqkqff{fqkdufgqqkw{fqkqff{fqkw{yd}xqkqff{fqkagqfkqff{f@FAQ>>O>SkYVANG	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>kQR	tsx{vuxgokkGWRkC]YQRGZki[GD[EZLNoYLW ^L@Ni>>>]Rsx{vuxgokkGWRkCGC  VMVVk iSkYVANGsx{vuxgokkGWRkCGC  VMVVk ikQRkQR			SkYVANGFQ@AFZ>>>>I>Z^kkDCPSE^ CUkNWCUNEM>]RPQR]ZQPYLW ^L@N O>UBGW\X\ZU S	AQ_^@\LQBMLA[XS>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiUBGW\X\ZU SoiO>QSZYDXPBXY]	tsx{vuxgokkGWRkBYEVDGkUNk iUBGW\X\ZU SoiRUXGQZAXXLL>]Rsx{vuxgokkGWRkCGC  VMVVk iQSZYDXPBXY]sx{vuxgokkGWRkUAU[DUV]kWkiQSZYDXPBXY]XSDQk^Y[_N[ XCDS]V]N]\U[DX C			O>GP QNZkML	tsx{vuxgokkGWRk@Y@R NPPDCC@kiUBGW\X\ZU SoiC[Q BXU tsx{vuxgokkGWRkBYEVDGkUNk iUBGW\X\ZU SoiU_GSMD@V RUXGQZAXX>>>]RGP QNZkML		QSZYDXPBXY]tsx{vuxgokkGWRkYL SYLQFC@ ^kiUBGW\X\ZU SoiUBGW\X\ZU SoiU_GSMD@V >I>I>AZGQ@UBGW\X\ZU SQSZYDXPBXY]GP QNZkML>I>IWU@W\`\F[CUVXQQWVWGU]_V_PBO>IWU@W\qLWQD@][ZQWVWGU]_V_PBO>>>>I>>I>RAZW@][ZXWGN\B^[M\@AGXG_QLkAW@D\UBA>>>>O>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iXG_QLkAW@D\UBAFQ@AFZ>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iRS^]Q]]ZB@[U XG_QLkAW@D\UBAFN^N@DQNMVL^O>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>>>>]RS]^CLWANUZsx{vuxgokkGWRkWBDQ[VVAZE\kiZPYML@XGQE@FAQFQ@AFZ>I>I>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iNWCUNEM XG_QLkAW@D\UBAFN^N@DQNMVL^O>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>]RS]^CLWANUZG@F]DWGXUG\QGZPYML@XGQEFQ@AFZ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiZPYML@XGQEU_GSMD@V 		RUXGQO>RFCAX\R[YS	DFQSkFQDXUWQkWUXXVUW_YLW ^L@N U_GSMD@V ZPYML@XGQE>]Rsx{vuxgokkGWRkCGC  VMVVk iRFCAX\R[YSRFCAX\R[YS		ZPYML@XGQES]^CLWANUZRFCAX\R[YSFQ@AFZ>I>>I>I>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iYLW ^L@N XG_QLkAW@D\UBAFN^N@DQNMVL^O>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>>]RS]^CLWANUZsx{vuxgokkGWRkR_]RRR^ ESkiUFFUMXSDQk^Y[_N[  NWCUNEM UFFUMhhhZPYML@XGQEFQ@AFZ>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiZPYML@XGQEU_GSMD@V 		RUXGQO>RFCAX\R[YS	DFQSkFQDXUWQkWUXXVUW_C[Q BXU YLW ^L@N ZPYML@XGQE>]Rsx{vuxgokkGWRkCGC  VMVVk iRFCAX\R[YSRFCAX\R[YS		ZPYML@XGQES]^CLWANUZRFCAX\R[YSFQ@AFZ>I>I>>>I>FQ@AFZXG_QLkAW@D\UBA>>>>I>RAZW@][Z_AX kFk \XUULFZRR_QCDM^ @W>O>>>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @WHHsx{vuxgokkGWRkUAU[DUV]kWkiRR_QCDM^ @WNWCUNEM  			RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiRR_QCDM^ @WXSDQk^Y[_N[ 			RUXGQFQ@AFZRUXGQ>>>>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iU_GSMD@V RR_QCDM^ @WFN^N@DQNMVL^O>>>>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>>]RS]^CLWANUZsx{vuxgokkGWRkWBDQ[VVAZE\kiZPYML@XGQE@FAQFQ@AFZ@FAQ>I>I>>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iNWCUNEM RR_QCDM^ @WFN^N@DQNMVL^O>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>]RS]^CLWANUZG@F]DWGXUG\QGZPYML@XGQEFQ@AFZ@FAQ>I>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>]Rsx{vuxgokkGWRkUAU[DUV]kWkiZPYML@XGQERS^]Q]]ZB@[U 			RUXGQW[Z@]ZAQ>>>RFCAX\R[YS	DFQSkFQDXUWQkWUXXVUW_RS^]Q]]ZB@[U RS^]Q]]ZB@[U ZPYML@XGQE>]Rsx{vuxgokkGWRkCGC  VMVVk iRFCAX\R[YSRFCAX\R[YS		ZPYML@XGQES]^CLWANUZRFCAX\R[YSFQ@AFZ@FAQ>>>>I>I>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iNWCUNEM RR_QCDM^ @WFN^N@DQNMVL^O>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>]RS]^CLWANUZsx{vuxgokkGWRkR_]RRR^ ESkiUFFUMXSDQk^Y[_N[  YLW ^L@N UFFUMhhhZPYML@XGQEFQ@AFZ@FAQ>I>R[FQUW\FN^N@DQNMVL^oiUGZPYML@XGQEO>]Rsx{vuxgokkGWRkUAU[DUV]kWkiZPYML@XGQEU_GSMD@V 			RUXGQW[Z@]ZAQ>RFCAX\R[YS	DFQSkFQDXUWQkWUXXVUW_NWCUNEM RS^]Q]]ZB@[U ZPYML@XGQE>]Rsx{vuxgokkGWRkCGC  VMVVk iRFCAX\R[YSRFCAX\R[YS		ZPYML@XGQES]^CLWANUZRFCAX\R[YSFQ@AFZ@FAQ>I>I>FQ@AFZRUXGQ>I>>>>RAZW@][ZD^\[ GECU_NDSQ]_FXRR_QCDM^ @W>>>O>>>]Rsx{vuxgokkGWRkCGC  VMVVk iRR_QCDM^ @WHHRR_QCDM^ @W			FQ@AFZ>FQ@AFZsx{vuxgokkGWRkUQ Y]ZXWDkiU_GSMD@V sx{vuxgokkGWRkQDZV_kiRR_QCDM^ @W WCLB@]UGWCLB@]UGoi>I>RAZW@][ZE[BD@ER_  MBAZNENDELUZDQD^Z\BFZDNZGCZGBU_ NQDLS[G[S	ZAXX>O>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHNENDELUZDQD^Z\B			FQ@AFZNENDELUZDQD^Z\B>>>>[F[CV_RBQ[RU	C[Q BXUFZDNZGCZGBXSDQk^Y[_N[  >>\MkR ADAkL[S	>NCVCES\@	>>>C\]XQNCVCES\@LWL O>>>CXVXZX[ ^Q[VD	sx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\B[F[CV_RBQ[RU>]RCXVXZX[ ^Q[VD			RUXGQVFQU_>CAEL_]RYEF	CXVXZX[ ^Q[VDsx{vuxgokkGWRkD@WYYENNCMMkki[F[CV_RBQ[RU>>>>CM_SkRkN^	sx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BNWCUNEM CAEL_]RYEF>]RCM_SkRkN^			RUXGQHHCM_SkRkN^CAEL_]RYEF
 O>>>\MkR ADAkL[S	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCAEL_]RYEF>NENDELUZDQD^Z\B	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCAEL_]RYEF>W[Z@]ZAQ>>>>I>^ZD@XMBkM\	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCAEL_]RYEFCM_SkRkN^CAEL_]RYEF>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U ^ZD@XMBkM\O>\MkR ADAkL[S	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCAEL_]RYEF>NENDELUZDQD^Z\B	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCAEL_]RYEF>W[Z@]ZAQ>I>_E^ANCYG	C[Q BXUFZDNZGCZGBNWCUNEM ^ZD@XMBkM\RS^]Q]]ZB@[U >\RG^_QB_YWQ	sx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\B_E^ANCYGCM_SkRkN^>]R\RG^_QB_YWQ			RUXGQVFQU_>\MkR ADAkL[S	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCXVXZX[ ^Q[VD>FMFPU_Sk 	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\BCXVXZX[ ^Q[VD\RG^_QB_YWQsx{vuxgokkGWRkD@WYYENNCMMkki_E^ANCYGCXVXZX[ ^Q[VD>>>]RU_ NQDLS[G[S		ZAXXO>]MC[kQAAGC	sx{vuxgokkGWRk_[B\CCNMkiU_ NQDLS[G[SFMFPU_Sk >]Rsx{vuxgokkGWRkCGC  VMVVk i]MC[kQAAGC\MkR ADAkL[S	]MC[kQAAGC>IQXGQO>\MkR ADAkL[S	FMFPU_Sk >I>NENDELUZDQD^Z\B	sx{vuxgokkGWRkQDZV_kiNENDELUZDQD^Z\B\RG^_QB_YWQsx{vuxgokkGWRkD@WYYENNCMMkki_E^ANCYG>I>FQ@AFZ\MkR ADAkL[SNENDELUZDQD^Z\B>I>RAZW@][ZX]SF kFV]NUUXG_QLkAW@D\UBA>>>O>FQ@AFZ>>>I>RAZW@][Z]FMkVXW[k@XG_QLkAW@D\UBA>>>O>]Rsx{vuxgokkGWRkCGC  VMVVk iXG_QLkAW@D\UBAFQ@AFZ>>>]RPQR]ZQPU_GSMD@V  FQ@AFZXG_QLkAW@D\UBA>>>BMQQ[APNN	SL@D ]FAVZuvgdu`|U_GSMD@V >>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEM BMQQ[APNNU_GSMD@V XG_QLkAW@D\UBAFQ@AFZ>FQ@AFZXG_QLkAW@D\UBA>>>>I>RAZW@][ZGCUPYVB\DZUAANENDELUZDQD^Z\B>O>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHNENDELUZDQD^Z\B			FQ@AFZNENDELUZDQD^Z\B>ZFR GB^_Z	E[BD@ER_  MBAZNENDELUZDQD^Z\BXSDQk^Y[_N[  U_GSMD@V >ZFR GB^_Z	E[BD@ER_  MBAZZFR GB^_ZXSDQk^Y[_N[  RS^]Q]]ZB@[U >]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@V ZFR GB^_Z>>>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZZFR GB^_Z	NENDELUZDQD^Z\B>]R_AX kFk \XUULFZZFR GB^_ZO>>>>ZFR GB^_Z	E[BD@ER_  MBAZZFR GB^_ZRS^]Q]]ZB@[U RS^]Q]]ZB@[U >ZFR GB^_Z	E[BD@ER_  MBAZZFR GB^_ZC[Q BXU NWCUNEM >]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXU ZFR GB^_Z>I>FQ@AFZsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZZFR GB^_ZNENDELUZDQD^Z\B>I>RAZW@][ZRXSR@NGUZNENDELUZDQD^Z\B>O>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHPQR]ZQPU_GSMD@V  FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U NENDELUZDQD^Z\BFQ@AFZ@FAQ>WWYUA^]A_Y	SL@D ]FAVZuvgdu`|NWCUNEM LL>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iXSDQk^Y[_N[   NENDELUZDQD^Z\BRXCPEVWDP^]P\O>R[FQUW\RXCPEVWDP^]P\oiUGM\Xk@[E^AZO>>]Rsx{vuxgokkGWRkQDZV_kiM\Xk@[E^AZLL 			WWYUA^]A_YFQ@AFZ@FAQ>I>I>kPP	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiuvgdu`|C[Q BXU >>>>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iC[Q BXU NENDELUZDQD^Z\BkPYO>R[FQUW\kPYoiUGD AMQY \O>]RD AMQY \			kPPFQ@AFZ@FAQ>I>I>FQ@AFZRUXGQ>I>>>>RAZW@][ZW]M^UkQ_QNYVBL\>>>>O>]R]GGQ@ksq`oRS^]Q]]ZB@[U iHHsx{vuxgokkGWRkCGC  VMVVk iksq`oRS^]Q]]ZB@[U iHHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  FQ@AFZ>AQVCCEY@	tSQ@k[D@][ZC[Q BXU UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iAQVCCEY@FQ@AFZ>>>[kC] Ak	G@F]ZSksq`oNWCUNEM i>YZB]R]A	UFFUM>]R]GGQ@AQVCCEY@o@iYZB]R]Aoi	G@F]ZSAQVCCEY@o@i>]R]GGQ@AQVCCEY@oU_GSMD@V isx{vuxgokkGWRkWBSB\_k iAQVCCEY@oRS^]Q]]ZB@[U iO>R[FQUW\AQVCCEY@oC[Q BXU iUGWZRCRAAZRO>]Rsx{vuxgokkGWRkWBSB\_k iWZRCRAAZR]GGQ@WZRCRAAZRo@iYZB]R]Aoi	G@F]ZSWZRCRAAZRo@i>I>I>GZMEL[	RUXGQ>R[FQUW\YZB]R]AUGVAWDBO>]RVAWDB			W[Z@]ZAQ>>>>GZMEL[	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  \UG\kQEAUXGVAWDB[kC] AkVAWDB			[kC] Ak>>]RGZMEL[VFQU_>I>]RGZMEL[FQ@AFZ>>>>sx{vuxgoC[Q BXU  i	[kC] Ak>>>>VMR^VBCUFWXDU_GSMD@V NWCUNEM  >]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM  O>sx{vuxgokkGWRkA[^M[ DkiXSDQk^Y[_N[   >I>I>>>RAZW@][ZFZUkVNAGASLWPF^XUU>>O>]RQYD@Msx{vuxgoU_GSMD@V  iHHsx{vuxgokkGWRkCGC  VMVVk isx{vuxgoC[Q BXU   iFQ@AFZ>]RQYD@Msx{vuxgoRS^]Q]]ZB@[U  iFQ@AFZ>sx{vuxgoXSDQk^Y[_N[   i	@FAQ>>QW\[hZgwsx{vuxgoC[Q BXU   iYLW ^L@N  >I>RAZW@][ZVF]@EPQ[kN_M>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N  FQ@AFZRUXGQ>WCLB@]UG	tSQ@k[D@][ZNWCUNEM >]Rsx{vuxgokkGWRkCGC  VMVVk iWCLB@]UGHHsx{vuxgokkGWRkUAU[DUV]kWkiWCLB@]UGU_GSMD@V  		FQ@AFZRUXGQ>>NkBUEUP@LF	]Z@sx{vuxgokkGWRkQDZV_kiWCLB@]UG>]RNkBUEUP@LFsx{vuxgokkGWRkNWYM^SkLZ[BNkiNkBUEUP@LF
FQ@AFZRUXGQ>FQ@AFZ@FAQ>>>I>RAZW@][ZMRFkUDFEFUZDCPZkSGSNUN@E^LP_[^>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VHHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U  FQ@AFZRUXGQ>>AQVCCEY@	tSQ@k[D@][ZRS^]Q]]ZB@[U UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iAQVCCEY@AQVCCEY@	UFFUM>]R]GGQ@AQVCCEY@oNWCUNEM iHHsx{vuxgokkGWRkWBSB\_k iAQVCCEY@oYLW ^L@N iO>C^VBMP_RLULMA	UFFUM>]R]GGQ@AQVCCEY@o@iAQVCCEY@oDiAQVCCEY@oViO>EXU@SYLQGZ	G@F]ZSAQVCCEY@oDi>[]P]VSDV@W]VY	G@F]ZSAQVCCEY@oVi>C^VBMP_RLULMAosx{vuxgokkGWRkk[AFM@ZWUECkiEXU@SYLQGZi	UFFUM@	
G@F]ZSAQVCCEY@o@iD	
EXU@SYLQGZV	
[]P]VSDV@W]VYYLW ^L@N  	
]GGQ@AQVCCEY@oC[Q BXU i]Z@AQVCCEY@oXSDQk^Y[_N[  isx{vuxgokkGWRkNWYM^SkLZ[BNkiU_GSMD@V 	
Z	
tsx{vuxgokkGWRk@Y@R NPPDCC@ki[]P]VSDV@W]VY]Z@tsx{vuxgokkGWRkDNNU_UYWXVVki[]P]VSDV@W]VY			>GP QNZkML	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tYPkR]XQEXU@SYLQGZRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iGP QNZkMLGP QNZkML		C^VBMP_RLULMAosx{vuxgokkGWRkk[AFM@ZWUECkiEXU@SYLQGZio\i	GP QNZkML>AZGQ@EXU@SYLQGZ[]P]VSDV@W]VYGP QNZkML>I>>>AQVCCEY@	UFFUMXSDQk^Y[_N[  	
C^VBMP_RLULMA>I>^ZD@XMBkM\	sx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUN>>>\GY\VAZ Q[	VF]@EPQ[kN_M>DDFMFGQ	]GGQ@AQVCCEY@oC[Q BXU io^ZD@XMBkM\i>>]RDDFMFGQO>>>>AQVCCEY@oXSDQk^Y[_N[  io^ZD@XMBkM\ioC[Q BXU  i	sx{vuxgokkGWRkNWYM^SkLZ[BNki>AQVCCEY@oU_GSMD@V io^ZD@XMBkM\ioSi	sx{vuxgokkGWRkPX^@X\kki@FAQ>AQVCCEY@oNWCUNEM io^ZD@XMBkM\ioXSDQk^Y[_N[  i	>AQVCCEY@oU_GSMD@V io^ZD@XMBkM\ioZi	@E^LP_[^			>AQVCCEY@oU_GSMD@V io^ZD@XMBkM\ioC[Q BXU i	\GY\VAZ Q[>>AQVCCEY@oU_GSMD@V io^ZD@XMBkM\ioXSDQk^Y[_N[  i	sx{vuxgokkGWRkNWYM^SkLZ[BNki>AQVCCEY@oXSDQk^Y[_N[  io^ZD@XMBkM\ioC[Q BXU i	>AQVCCEY@oYLW ^L@N io^ZD@XMBkM\ioRS^]Q]]ZB@[U i	>>>>AQVCCEY@oXSDQk^Y[_N[  io^ZD@XMBkM\ioYLW ^L@N i	>]R^EQW_ZP\[\_^S^AQVCCEY@oC[Q BXU io^ZD@XMBkM\ioVi@E^LP_[^O>>>>[]\CNNBEZB[Q\APGU_GSMD@V YLW ^L@N >FQ@AFZRUXGQ>>>I>>>>IQXGQO>>]Rsx{vuxgokkGWRkEMVLY\AkiAQVCCEY@oYLW ^L@N i
	O>[]\CNNBEZB[Q\APGU_GSMD@V NWCUNEM  >FQ@AFZRUXGQ>I>PLDRFkX ]D]@Y]	GM_EAV^VFW>LWP^ ZVGW	PLDRFkX ]D]@Y]NWCUNEM SL@D ]FAVZDCPZkSGSNUNXSDQk^Y[_N[  >]R^EQW_ZP\[\_^S^LWP^ ZVGW@E^LP_[^O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U C[Q BXU >FQ@AFZRUXGQ>I>AQVCCEY@oRS^]Q]]ZB@[U io^ZD@XMBkM\i	UFFUM@	
QWkW^LS NNARLWL D	
DCPZkSGSNUNV	
LWP^ ZVGWYLW ^L@N  	
sx{vuxgokkGWRkNWYM^SkLZ[BNkiS	
sx{vuxgokkGWRkPX^@X\kki@FAQRS^]Q]]ZB@[U 	
Z	
@E^LP_[^			RS^]Q]]ZB@[U 	
\GY\VAZ Q[RS^]Q]]ZB@[U 	
sx{vuxgokkGWRkNWYM^SkLZ[BNkiXSDQk^Y[_N[  	
NWCUNEM 	
XSDQk^Y[_N[  	
>I>G]SYDLRU@	tADPU@Qk[D@][ZNWCUNEM AQVCCEY@YLW ^L@N>>]RG]SYDLRU@O>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tCDkWUW\QkPQXQ@QNWCUNEM RS^]Q]]ZB@[U >QV]BWVLLN	tSQ@k[D@][ZRS^]Q]]ZB@[U UFFUM>BSDGBS_YADM	sx{vuxgokkGWRkWBSB\_k iQV]BWVLLN]GGQ@QV]BWVLLNoNWCUNEM io^ZD@XMBkM\isx{vuxgokkGWRkWBSB\_k iQV]BWVLLNoXSDQk^Y[_N[  io^ZD@XMBkM\i>]GGQ@QV]BWVLLNoU_GSMD@V io^ZD@XMBkM\ioSiG@F]ZSQV]BWVLLNoRS^]Q]]ZB@[U io^ZD@XMBkM\ioSi			G@F]ZSAQVCCEY@oC[Q BXU io^ZD@XMBkM\ioSi>]RBSDGBS_YADMO>]RDDFMFGQUC[WM Z AQVCCEY@oXSDQk^Y[_N[  io^ZD@XMBkM\ioVi>[]\CNNBEZB[Q\APGXSDQk^Y[_N[  RS^]Q]]ZB@[U  >>FQ@AFZRUXGQ>I>I>>>>sx{vuxgokkGWRkA[^M[ DkiU_GSMD@V >FQ@AFZ@FAQ>I>>RAZW@][ZCMM[CQBFBQRWkCLDWFE\>O>]R]GGQ@sx{vuxgoNWCUNEMiHHsx{vuxgokkGWRkR@YW RREk isx{vuxgoC[Q BXUisx{vuxgoYLW ^L@Ni	>FQ@AFZsx{vuxgoYLW ^L@N i>>>I>RAZW@][ZYLW[UL]YF^VN@G\]B@EV@GV[F>O>sx{vuxgoNWCUNEM i	]GGQ@sx{vuxgoC[Q BXU isx{vuxgokkGWRkR@YW RREk isx{vuxgoYLW ^L@N isx{vuxgoU_GSMD@V iRX[U@\]B@EV@GV[F>>I>>>>RAZW@][ZkDWDA_U\_]PV F]SA@LDZEPEW[[>O>[WFS[DDS[ G@	CMM[CQBFBQRWkCLDWFE\>>>]R[WFS[DDS[ G@	FQ@AFZUFFUM>P\EZ R\GU	sx{vuxgokkGWRk]LMMNL  Gk isx{vuxgokkGWRkPYBC^AAPLk i]Z@[WFS[DDS[ G@>ENG]k^WEkWXFG	sx{vuxgokkGWRkPX^@X\kki@FAQ>ZWE]AFQ]XQ	tsx{vuxgokkGWRkVkFMXL ki@LDZEPEW[[UFFUMU_GSMD@V	
P\EZ R\GURS^]Q]]ZB@[U 	
RUXGQRS^]Q]]ZB@[U 	
@FAQC[Q BXU	
NWCUNEM	
LRVPWLU  NWCUNEM	
UFFUMXSDQk^Y[_N[  	
C[Q BXU NWCUNEM 	
U_GSMD@V >YLW[UL]YF^VN@Gsx{vuxgokkGWRkPX^@X\kki@FAQENG]k^WEkWXFG>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U ]GkCDkQFF[FZWE]AFQ]XQFQ@AFZUFFUMRUXGQ>Y@Z[D[X	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU  ]Z@CDkFQY[@QkFQ@F]QBQkFQGD[ZGQkW[PQZWE]AFQ]XQ>FQ@AFZUFFUMY@Z[D[XY@Z[D[X
sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU G@F]ZSCDkFQY[@QkFQ@F]QBQkV[PMZWE]AFQ]XQ>I>RAZW@][Z]__CZGUREPA@SB^DCPZkSGSNUN>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU HHsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VHHsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU FQ@AFZ>>>AQVCCEY@	tSQ@k[D@][ZC[Q BXU UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iAQVCCEY@HH]GGQ@AQVCCEY@oC[Q BXU iHHsx{vuxgokkGWRkWBSB\_k iAQVCCEY@oNWCUNEM iFQ@AFZ>>>^ZD@XMBkM\	sx{vuxgokkGWRkk[AFM@ZWUECkiDCPZkSGSNUN>>>>]R]GGQ@AQVCCEY@oC[Q BXU io^ZD@XMBkM\iFQ@AFZ>>N_QFQSGPkGSL]	tYPkR]XQDCPZkSGSNUN>]Rsx{vuxgokkGWRkCGC  VMVVk iN_QFQSGPkGSL]HHN_QFQSGPkGSL]			FQ@AFZ>AQVCCEY@oNWCUNEM io^ZD@XMBkM\io\i	N_QFQSGPkGSL]>tADPU@Qk[D@][ZRS^]Q]]ZB@[U AQVCCEY@RS^]Q]]ZB@[U >I>>>RAZW@][ZB BNF@WDY kUD]F^WZRCRAAZR>O>kkM[S\@GkUZ[[	tsx{vuxgokkGWRkBYEVDGkUNk iWZRCRAAZRoVi>>>>]Rsx{vuxgokkGWRkCGC  VMVVk ikkM[S\@GkUZ[[FQ@AFZRUXGQ>]RQYD@MWZRCRAAZRo\isx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  O>VQBZWGF	tYPkR]XQWZRCRAAZRoDi>]Rsx{vuxgokkGWRkCGC  VMVVk iVQBZWGFVQBZWGF		VQBZWGF		WZRCRAAZRo\iFQ@AFZRUXGQ>AZGQ@VQBZWGF>I>]RkkM[S\@GkUZ[[			O>>>>]RQYD@MWZRCRAAZRoZiFQ@AFZRUXGQ>YF WAZXM]	tsx{vuxgokkGWRk@Y@R NPPDCC@kiWZRCRAAZRoDi>]RYF WAZXM]O>SUB\XXALLBWR W\F XWZRCRAAZRoDi >YF WAZXM]	UC[WM Z WZRCRAAZRoDi>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vt[DWUW\Qk]ZBUX]PU@QWZRCRAAZRoDi@FAQ>FQ@AFZYF WAZXM]>>>>I>]R^EQW_ZP\[\_^S^WZRCRAAZRoDikkM[S\@GkUZ[[FQ@AFZRUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vt[DWUW\Qk]ZBUX]PU@QWZRCRAAZRoDi@FAQ>FQ@AFZ@FAQ>>>I>RAZW@][ZDEUWL@^DCLLXM>O>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU FQ@AFZ>]RQYD@Msx{vuxgoC[Q BXUiFQ@AFZ>>>>]RPZEURB[UWFUPRS^]Q]]ZB@[U FQ@AFZ>@FMO>AQVCCEY@	tSQ@k[D@][ZC[Q BXU UFFUM>]Rsx{vuxgokkGWRkWBSB\_k iAQVCCEY@FQ@AFZ>>]R]GGQ@AQVCCEY@oXSDQk^Y[_N[  iHHsx{vuxgokkGWRkWBSB\_k iAQVCCEY@oXSDQk^Y[_N[  iO>C^VBMP_RLULMA	UFFUM>]R]GGQ@AQVCCEY@o@iAQVCCEY@oDiAQVCCEY@oViO>EXU@SYLQGZ	G@F]ZSAQVCCEY@oDi>[]P]VSDV@W]VY	G@F]ZSAQVCCEY@oVi>C^VBMP_RLULMAosx{vuxgokkGWRkk[AFM@ZWUECkiEXU@SYLQGZi	UFFUM@	
G@F]ZSAQVCCEY@o@iD	
EXU@SYLQGZV	
[]P]VSDV@W]VYC[Q BXU  	
]GGQ@AQVCCEY@oC[Q BXU  i]Z@AQVCCEY@oXSDQk^Y[_N[  isx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Q BXU 	
Z	
tsx{vuxgokkGWRk@Y@R NPPDCC@ki[]P]VSDV@W]VY]Z@tsx{vuxgokkGWRkDNNU_UYWXVVki[]P]VSDV@W]VY			>>>GP QNZkML	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU tYPkR]XQEXU@SYLQGZRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iGP QNZkMLGP QNZkML		C^VBMP_RLULMAosx{vuxgokkGWRkk[AFM@ZWUECkiEXU@SYLQGZio\i	GP QNZkML>>AZGQ@EXU@SYLQGZ[]P]VSDV@W]VYGP QNZkML>I>AQVCCEY@	UFFUMYLW ^L@N 	
C^VBMP_RLULMA>I>]RQYD@MAQVCCEY@oU_GSMD@V iO>tPQXQ@Qk[D@][ZXSDQk^Y[_N[  >FQ@AFZ>I>>>]RVF]@EPQ[kN_MO>YLDk_^F^	RUXGQ>R[FQUW\AQVCCEY@oNWCUNEM iUGUPXUUALYRW]	
AMUC^ZMEC_k_O>]Rsx{vuxgokkGWRkWBSB\_k iAMUC^ZMEC_k_QYD@MAMUC^ZMEC_k_oU_GSMD@V iO>AQVCCEY@oU_GSMD@V ioUPXUUALYRW]ioYLW ^L@N  i	>YLDk_^F^	@FAQ>>>>I>I>]RYLDk_^F^tADPU@Qk[D@][ZC[Q BXU AQVCCEY@U_GSMD@V >AZGQ@YLDk_^F^UPXUUALYRW]AMUC^ZMEC_k_>FQ@AFZ>I>G@U@]WSNBURk]]NAL	RUXGQ>]RSNBURk]]NALFQ@AFZ>SNBURk]]NAL	@FAQ>NUkMWCCX ZR[GC	sx{vuxgokkGWRk]UFVD[U \kiAQVCCEY@oC[Q BXU i>^[D@@BEF	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tsx{vuxgokkGWRkZ^QDVBUV_FRki>QXGQ]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tsx{vuxgokkGWRk^]XY^D VSM Vk i>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Ntsx{vuxgokkGWRkGBYDVWBARCki@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N HHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  FQ@AFZ>PX[D]GP]C	\[YQkAFX>@]@ WSVA]VRR 	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V CDkX[S]ZkAFXPX[D]GP]CXSDQk^Y[_N[  >>>[F][EAG]YFADE	RUXGQ>Z\MDFNGUQA	@FAQ>>>[WFS[DDS[ G@	j>R[FQUW\AQVCCEY@oRS^]Q]]ZB@[UiUG^ZD@XMBkM\	
WZRCRAAZRO>]RCMM[CQBFBQRWkCLDWFE\	VFQU_>]Rsx{vuxgokkGWRkWBSB\_k iWZRCRAAZRHHQYD@MWZRCRAAZRo@iHHQYD@MWZRCRAAZRoDiHHQYD@MWZRCRAAZRoViO>AZGQ@AQVCCEY@oXSDQk^Y[_N[ io^ZD@XMBkM\i>[F][EAG]YFADE	@FAQ>W[Z@]ZAQ>I>]R]GGQ@WZRCRAAZRoZiHH]GGQ@WZRCRAAZRo\iO>]R]GGQ@WZRCRAAZRoZiWZRCRAAZRoZi	tsx{vuxgokkGWRk@Y@R NPPDCC@kiWZRCRAAZRoVi]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiWZRCRAAZRoVi			>]R]GGQ@WZRCRAAZRo\isx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U O>@RDAVBFB	tYPkR]XQWZRCRAAZRoDi>>]Rsx{vuxgokkGWRkCGC  VMVVk i@RDAVBFB@RDAVBFB		WZRCRAAZRo\i	@RDAVBFB>AZGQ@@RDAVBFB>I>AQVCCEY@oC[Q BXUio^ZD@XMBkM\i	WZRCRAAZR>[F][EAG]YFADE	@FAQ>I>]RQYD@MWZRCRAAZRoRS^]Q]]ZB@[UiO>WZRCRAAZRoC[Q BXUi	>WZRCRAAZRoU_GSMD@V i	sx{vuxgokkGWRkNWYM^SkLZ[BNki>WZRCRAAZRoU_GSMD@Vi	>>>WZRCRAAZRoNWCUNEM i	>>>>WZRCRAAZRoRS^]Q]]ZB@[U i	>WZRCRAAZRoYLW ^L@N i	>AQVCCEY@oRS^]Q]]ZB@[Uio^ZD@XMBkM\i	WZRCRAAZR>[F][EAG]YFADE	@FAQ>I>]RQYD@MWZRCRAAZRoNWCUNEM iO>AQVCCEY@oYLW ^L@Nio^ZD@XMBkM\ioXSDQk^Y[_N[  i	]Z@WZRCRAAZRoYLW ^L@N i>WZRCRAAZRoC[Q BXU i	]Z@WZRCRAAZRoNWCUNEM i>[F][EAG]YFADE	@FAQ>>>>I>]RQYD@MWZRCRAAZRoRS^]Q]]ZB@[Uisx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@WZRCRAAZRoNWCUNEMiW[Z@]ZAQ>>]R[WFS[DDS[ G@	VFQU_>>>>[WFS[DDS[ G@>@YRWFGQ_QR^^] 	RS^]Q]]ZB@[Usx{vuxgokkGWRkBM__SPLRXDCkiWZRCRAAZRo@iRS^]Q]]ZB@[Usx{vuxgokkGWRkLFUXCD_ k i>X]G@Y@Z[D[XPR_kSRMA	kDWDA_U\_]PV F]SAPX[D]GP]C@YRWFGQ_QR^^] >]RY@Z[D[X			VFQU_>]RY@Z[D[X
Z\MDFNGUQA	RUXGQ>]RY@Z[D[X			sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VCMM[CQBFBQRWkCLDWFE\
sx{vuxgokkGWRkP_^ERR[k[ki>]RY@Z[D[X			O>X]G@Y@Z[D[XPR_kSRMA	kDWDA_U\_]PV F]SAPX[D]GP]C@YRWFGQ_QR^^] >]RY@Z[D[X			VFQU_>]RY@Z[D[X
Z\MDFNGUQA	RUXGQ>I>]RY@Z[D[X	O>>>AQVCCEY@oNWCUNEMio^ZD@XMBkM\ioYLW ^L@Ni>[F][EAG]YFADE	@FAQ>W[Z@]ZAQ>I>]RY@Z[D[X
	  O>>]RB BNF@WDY kUD]F^WZRCRAAZRO>[]\CNNBEZB[Q\APGC[Q BXU XSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiWZRCRAAZRoDi>^[D@@BEFo^ZD@XMBkM\i	WZRCRAAZR>AZGQ@AQVCCEY@oYLW ^L@Nio^ZD@XMBkM\i>IQXGQO>AQVCCEY@oNWCUNEMio^ZD@XMBkM\ioC[Q BXUi>>>I>[F][EAG]YFADE	@FAQ>>>>W[Z@]ZAQ>I>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiPR_kSRMANWCUNEMWZRCRAAZRo@iYLW ^L@N  		RUXGQO>>>>^[D@@BEFo^ZD@XMBkM\i	WZRCRAAZR>AZGQ@AQVCCEY@oC[Q BXUio^ZD@XMBkM\i>[F][EAG]YFADE	@FAQ>W[Z@]ZAQ>>>I>>>X]G@FUP[LQ DCN\MNMk_P[F]	kDWDA_U\_]PV F]SA@]@ WSVA]VRR sx{vuxgokkGWRkUAU[DUV]kWki@]@ WSVA]VRR 			RUXGQXSDQk^Y[_N[ sx{vuxgokkGWRkBM__SPLRXDCkiWZRCRAAZRo@iRS^]Q]]ZB@[Usx{vuxgokkGWRkLFUXCD_ k i  >>>>]RFUP[LQ DCN\			VFQU_>>>]RFUP[LQ DCN\
Z\MDFNGUQA	RUXGQ>]RFUP[LQ DCN\
	 O>]RB BNF@WDY kUD]F^WZRCRAAZRO>[]\CNNBEZB[Q\APGU_GSMD@V U_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiWZRCRAAZRoDi>^[D@@BEFo^ZD@XMBkM\i	WZRCRAAZR>>>AZGQ@AQVCCEY@oYLW ^L@Nio^ZD@XMBkM\i>IQXGQO>AQVCCEY@oXSDQk^Y[_N[ io^ZD@XMBkM\ioRS^]Q]]ZB@[Ui>I>>>[F][EAG]YFADE	@FAQ>>W[Z@]ZAQ>>>>I>]Rsx{vuxgokkGWRkCGC  VMVVk iMNMk_P[F]sx{vuxgokkGWRkUAU[DUV]kWkiMNMk_P[F]RS^]Q]]ZB@[UWZRCRAAZRo@iNWCUNEM  		RUXGQO>^[D@@BEFo^ZD@XMBkM\i	WZRCRAAZR>AZGQ@AQVCCEY@oRS^]Q]]ZB@[Uio^ZD@XMBkM\i>[F][EAG]YFADE	@FAQ>W[Z@]ZAQ>I>AQVCCEY@oXSDQk^Y[_N[ io^ZD@XMBkM\ioU_GSMD@V i	]Z@]GGQ@AQVCCEY@oNWCUNEMio^ZD@XMBkM\ioU_GSMD@ViAQVCCEY@oNWCUNEMio^ZD@XMBkM\ioU_GSMD@Vi>]Rsx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@AQVCCEY@oRS^]Q]]ZB@[Uio^ZD@XMBkM\ioYLW ^L@N i
 O>AQVCCEY@oNWCUNEMio^ZD@XMBkM\ioU_GSMD@V i	>AQVCCEY@oC[Q BXUio^ZD@XMBkM\ioU_GSMD@Vi	sx{vuxgokkGWRkNWYM^SkLZ[BNkiLRUWLP >IQXGQO>>>>\FFQU\VAD	UFFUMj>N_PPVRC	]Z@AQVCCEY@oYLW ^L@Nio^ZD@XMBkM\ioRS^]Q]]ZB@[Ui>AQVCCEY@oU_GSMD@Vio^ZD@XMBkM\ioRS^]Q]]ZB@[Ui	sx{vuxgokkGWRkNWYM^SkLZ[BNki\FFQU\VADosx{vuxgokkGWRkPYBC^AAPLk iN_PPVRCji>AZGQ@\FFQU\VADN_PPVRC>I>>[F][EAG]YFADE	@FAQ>I>]RZ\MDFNGUQA[F][EAG]YFADEQYD@MAQVCCEY@oYLW ^L@NiO>^V^RVGGMF	RUXGQ>R[FQUW\AQVCCEY@oRS^]Q]]ZB@[UiUGZkGLWS^A@O>]R]Z@ZkGLWS^A@oU_GSMD@Vi
	LLO>^V^RVGGMF	@FAQ>>>VFQU_>I>I>]R^V^RVGGMFO>tADPU@Qk[D@][ZC[Q BXUC[Q BXUsx{vuxgokkGWRkNWYM^SkLZ[BNkiU_GSMD@V >[]\CNNBEZB[Q\APGYLW ^L@N NWCUNEM >R[FQUW\AQVCCEY@oU_GSMD@ViUGWDWFFGG	
ZkGLWS^A@O>]Rsx{vuxgokkGWRkWBSB\_k iZkGLWS^A@QYD@MZkGLWS^A@oNWCUNEMiAQVCCEY@oRS^]Q]]ZB@[UioWDWFFGGioC[Q BXUi	>I>[F][EAG]YFADE	@FAQ>I>IQXGQ]RZ\MDFNGUQAO>>>YQDMFCEU	tSQ@k[D@][ZYLW ^L@N>]Rsx{vuxgokkGWRkCGC  VMVVk iYQDMFCEUHHsx{vuxgokkGWRkUAU[DUV]kWkiYQDMFCEUXSDQk^Y[_N[ 		tADPU@Qk[D@][ZRS^]Q]]ZB@[URS^]Q]]ZB@[Usx{vuxgokkGWRkNWYM^SkLZ[BNkiRS^]Q]]ZB@[U >I>]R[F][EAG]YFADEO>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V tCDkWUW\QkPQXQ@QC[Q BXU YLW ^L@N>N_VU U^ W	tSQ@k[D@][ZNWCUNEM UFFUM>>]Rsx{vuxgokkGWRkWBSB\_k iN_VU U^ W]GGQ@N_VU U^ WoXSDQk^Y[_N[ isx{vuxgokkGWRkWBSB\_k iN_VU U^ WoXSDQk^Y[_N[ iO>R[FQUW\N_VU U^ WoU_GSMD@ViUGLEEWMCNCD]BSD	
MUCUSB]O>>]R]GGQ@AQVCCEY@oYLW ^L@NioLEEWMCNCD]BSDiW[Z@]ZAQ>]Rsx{vuxgokkGWRkUFBG[ZLZN Gk iLEEWMCNCD]BSDNUkMWCCX ZR[GC@FAQO>AQVCCEY@oXSDQk^Y[_N[ ioLEEWMCNCD]BSDi	MUCUSB]>W[Z@]ZAQ>I>>>>]R]GGQ@^[D@@BEFoLEEWMCNCD]BSDisx{vuxgokkGWRkWBSB\_k iMUCUSB]O>VRkN\]DCDVQFN	]GGQ@MUCUSB]oSiRX[U@MUCUSB]oSiRX[U@]GGQ@MUCUSB]oXSDQk^Y[_N[  iMUCUSB]oXSDQk^Y[_N[  i>>>SX@D[\GWN^GG	]GGQ@^[D@@BEFoLEEWMCNCD]BSDioSiRX[U@^[D@@BEFoLEEWMCNCD]BSDioSiRX[U@]GGQ@^[D@@BEFoLEEWMCNCD]BSDioXSDQk^Y[_N[  i^[D@@BEFoLEEWMCNCD]BSDioNWCUNEM i>>>]RVRkN\]DCDVQFN
SX@D[\GWN^GGAQVCCEY@oYLW ^L@NioLEEWMCNCD]BSDi	MUCUSB]>AZGQ@VRkN\]DCDVQFNSX@D[\GWN^GG>I>I>I>AZGQ@N_VU U^ WLEEWMCNCD]BSDMUCUSB]>>>>I>R[FQUW\^[D@@BEFUG@S@]]WLWCLQ]	
RLES Q^FGVO>]R]GGQ@AQVCCEY@oYLW ^L@Nio@S@]]WLWCLQ]iUC[WM Z RLES Q^FGVoVi>I>AZGQ@^[D@@BEF@S@]]WLWCLQ]RLES Q^FGV>]RQYD@MAQVCCEY@oXSDQk^Y[_N[ itPQXQ@Qk[D@][ZNWCUNEM>QXGQ]R[F][EAG]YFADEtADPU@Qk[D@][ZYLW ^L@NAQVCCEY@XSDQk^Y[_N[  >>IR]ZUXXMO>L^U[US^\kM^RS^]Q]]ZB@[U>I>I>RAZW@][ZBDNA^B[\^GC@BZNENDELUZDQD^Z\B>O>FQ@AFZsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\Bsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BYLW ^L@N 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BYLW ^L@N		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BC[Q BXU 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BYLW ^L@N 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BC[Q BXU		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BC[Q BXU		RUXGQ>I>RAZW@][ZDUWNNYGDWkEP\]U_SG^NENDELUZDQD^Z\B>O>]RBDNA^B[\^GC@BZNENDELUZDQD^Z\BFQ@AFZRUXGQ>]R_AX kFk \XUULFZNENDELUZDQD^Z\BFQ@AFZ@FAQ>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iRS^]Q]]ZB@[UNENDELUZDQD^Z\BWCLB@]UGO>R[FQUW\WCLB@]UGoiUGEVVNAEL\O>]RBQFG][ZkW[YDUFQEVVNAEL\XCDS]V]N]\U[DX CFQ@AFZ@FAQ>I>FQ@AFZRUXGQ>I>>>FQ@AFZ@FAQ>I>>>>RAZW@][ZUNkWNUFRUR^]G^QMP LUkFX_AZZZFQ>O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLUkFX_AZZZFQHHtsx{vuxgokkGWRk_XXP] C^Mk iLUkFX_AZZZFQFQ@AFZ>>>PGA_N 	tsx{vuxgokkGWRkDNNU_UYWXVVkiLUkFX_AZZZFQ>]RPGA_N FQ@AFZ>]RPGA_N 
 O>>>>BYD\D@URSMD\\	tsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQRUXGQZAXX>]RBDNA^B[\^GC@BZBYD\D@URSMD\\FQ@AFZ>]RZ]ELLM]_XSBWGQLUkFX_AZZZFQ			RUXGQO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ YLW ^L@N sx{vuxgokkGWRkQANE SG_kXV\kiLUkFX_AZZZFQ>FQ@AFZ>>I>tsx{vuxgokkGWRk_GUYNZVVVk iLUkFX_AZZZFQD\DhZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUt[DWUW\Qk]ZBUX]PU@QLUkFX_AZZZFQ@FAQ>FQ@AFZ>I>>]RPGA_N 
LRLO>\X]G\QkLQLQV	G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQRUXGQZAXX >\\FYSGDU	PGA_N 
G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQRUXGQZAXXPGA_N  >@_GLQX[_LBW	\X]G\QkLQLQV\\FYSGDU>]R@_GLQX[_LBW		sx{vuxgokkGWRk\XL[WSGSNNWk  iNWCUNEM @_GLQX[_LBWV\AWN]GBZ@O>ZW^@XANZ	RUXGQ>R[FQUW\V\AWN]GBZ@oiUG@YCSZU[@UO>]RBQFG][ZkW[YDUFQ@YCSZU[@UXCDS]V]N]\U[DX CO>>>ZW^@XANZ	@FAQ>VFQU_>>>>I>I>]RZW^@XANZFQ@AFZ>I>>>>I>>>>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iLUkFX_AZZZFQ>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\Bsx{vuxgokkGWRkD@WYYENNCMMkkiNENDELUZDQD^Z\B
 NENDELUZDQD^Z\B	^UNF\NZMLZLZkN[XANENDELUZDQD^Z\B>>>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BFQ@AFZ>]RDUWNNYGDWkEP\]U_SG^NENDELUZDQD^Z\BFQ@AFZ>@VLLAC_\_ENW]@NDLUkFX_AZZZFQNENDELUZDQD^Z\B>I>RAZW@][Z@VLLAC_\_ENW]@NDLUkFX_AZZZFQNENDELUZDQD^Z\B>>>>O>>>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iNWCUNEM NENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZHHsx{vuxgokkGWRk\G[ML]GWkiZFR GB^_Z			HHsx{vuxgokkGWRk\G[ML]GWkiZFR GB^_Z			C[Q BXUZFR GB^_Z	D\DhZ>>>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiZFR GB^_Z
	  M[YQk NNVYMFB\ZFR GB^_ZZFR GB^_Z	D\DhZ>R\SMNMEZYDUUQY	tR]XQDQFYGLUkFX_AZZZFQ>R\SMNMEZYDUUQY	R\SMNMEZYDUUQY			RUXGQ R\SMNMEZYDUUQY  >PXXE]UPNN	tsx{vuxgokkGWRkUMX_NCYCkiLUkFX_AZZZFQ>_S_kVQNAB\A	tsx{vuxgokkGWRkW[_VWkXXkisx{vuxgokkGWRkWLGRkXNMY[kiLUkFX_AZZZFQRS^]Q]]ZB@[U >]R_S_kVQNAB\A			RUXGQFQ@AFZ>]Rtsx{vuxgokkGWRk_GUYNZVVVk i_S_kVQNAB\AZFR GB^_Z		sx{vuxgokkGWRkD@WYYENNCMMkkiZFR GB^_ZO>tsx{vuxgokkGWRkSXVSWM_EQki_S_kVQNAB\A>FQ@AFZ>>>>I>tsx{vuxgokkGWRkWWGZMMY]kRW^ki_S_kVQNAB\AR\SMNMEZYDUUQY>]Rtsx{vuxgokkGWRkX QBXDFYNZBk i_S_kVQNAB\ALUkFX_AZZZFQO>tsx{vuxgokkGWRkSXVSWM_EQki_S_kVQNAB\A>FQ@AFZ>I>>>]RPXXE]UPNNtsx{vuxgokkGWRkABFEYZ\]WX]@kiLUkFX_AZZZFQPXXE]UPNN>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ t[DWUW\Qk]ZBUX]PU@QLUkFX_AZZZFQ@FAQ>I>RAZW@][Z_GDPVPQLARBFYS^RNXG_QLkAW@D\UBA>O>]Rsx{vuxgokkGWRkCGC  VMVVk iXG_QLkAW@D\UBAFQ@AFZ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXU  XG_QLkAW@D\UBACFMEkZRFPO>[C[ALERkB	CFMEkZRFPoi>PGA_N 	tsx{vuxgokkGWRk@Y@R NPPDCC@ki[C[ALERkBtsx{vuxgokkGWRkDNNU_UYWXVVki[C[ALERkB>]RPGA_N HHPGA_N   HHPGA_N 
  O>>>>]RPGA_N 
   O>]]RB__ZRRX	tsx{vuxgokkGWRkC]YQRGZki[C[ALERkB>]Rsx{vuxgokkGWRkCGC  VMVVk i]]RB__ZRRX]]RB__ZRRX	[C[ALERkB>]]RB__ZRRX	sx{vuxgokkGWRkR_]RRR^ ESkihh]]RB__ZRRX>QVMXB\kSkVU	RUXGQ>GNQk[X]^XV	UFFUMPQR]ZQPXSDQk^Y[_N[   sx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|C[Q BXUPQR]ZQPU_GSMD@Vsx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fU_GSMD@V>R[FQUW\GNQk[X]^XVUG]F_QRDXO>]F_QRDX	sx{vuxgokkGWRkR_]RRR^ ESkihh]F_QRDX>]R]F_QRDX		sx{vuxgokkGWRkUAU[DUV]kWki]]RB__ZRRX]F_QRDX			O>QVMXB\kSkVU	@FAQ>VFQU_>I>I>]RQVMXB\kSkVUZ]ELLM]_XSBWGQ[C[ALERkB		RUXGQO>tsx{vuxgokkGWRkSXVSWM_EQki[C[ALERkB>tsx{vuxgokkGWRkSXVSWM_EQkisx{vuxgokkGWRkWLGRkXNMY[ki[C[ALERkBU_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\ki[C[ALERkBC[Q BXU>>IQXGQO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ RS^]Q]]ZB@[U sx{vuxgokkGWRkQANE SG_kXV\ki[C[ALERkB>I>I>>FQ@AFZ>>>>I>I>>>>FQ@AFZXG_QLkAW@D\UBA>>>>I>RAZW@][ZSWUPDSZ]DM_CkC>O>G@U@]W[C[ALERkB	ZAXX>]R[C[ALERkB			ZAXXO>EVVNAEL\	M_E@QREC][C[Q BXUZAXX>>]REVVNAEL\			ZAXXO>PF_VMM^Q	M_E@QREC][NWCUNEM>EVVNAEL\	sx{vuxgokkGWRkCGC  VMVVk iPF_VMM^Qsx{vuxgokkGWRkUAU[DUV]kWkiPF_VMM^QU_GSMD@V			>>YSWP_GN@FXXNWCUNEM EVVNAEL\XSDQk^Y[_N[  >AZGQ@PF_VMM^Q>I>[C[ALERkB	]Z@EVVNAEL\			>I>>>>FQ@AFZ[C[ALERkB>I>RAZW@][ZA] LR\DNSRGW[[>O>>]RPQR]ZQPRS^]Q]]ZB@[U  FQ@AFZ>@WS\XZ[Qk	uvgdu`|U_GSMD@V >>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WS\XZ[QkO>YZEL^C\@D_RS	sx{vuxgokkGWRkWLGRkXNMY[kiuvgdu`|C[Q BXU >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiYZEL^C\@D_RS@WS\XZ[Qk	YZEL^C\@D_RS>I>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WS\XZ[QkHHtsx{vuxgokkGWRk_XXP] C^Mk i@WS\XZ[QkFQ@AFZ>]]RB__ZRRX	tsx{vuxgokkGWRkC]YQRGZki@WS\XZ[Qk>]Rsx{vuxgokkGWRkCGC  VMVVk i]]RB__ZRRX]]RB__ZRRX		tsx{vuxgokkGWRk_XXP] C^Mk i]]RB__ZRRX@WS\XZ[Qk	]]RB__ZRRX>]Rtsx{vuxgokkGWRkDNNU_UYWXVVki@WS\XZ[Qk
   FQ@AFZ>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk i@WS\XZ[Qk>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BHHNENDELUZDQD^Z\B			FQ@AFZ>AABNkQ[G	sx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BU_GSMD@V 		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BNWCUNEM		RUXGQ>>>UBYQYV^WZSU	RUXGQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BRS^]Q]]ZB@[U			RUXGQO>]RQYD@Msx{vuxgoNWCUNEMiO>UBYQYV^WZSU	@FAQ>IQXGQO>>L[Pk[QSSGL	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMsx{vuxgokkGWRkLBBNYWPX^DkiRS^]Q]]ZB@[U>]Rtsx{vuxgokkGWRkY  PFNk iL[Pk[QSSGLHHtsx{vuxgokkGWRk_XXP] C^Mk iL[Pk[QSSGLUBYQYV^WZSU	@FAQ>I>I>>G\UVG@YL^S	RUXGQ>\QRC\DQUQE^	RUXGQ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXUNENDELUZDQD^Z\BPQR]ZQPYLW ^L@NO>>>>kUW	cdkw{z`qz`kp}fU_GSMD@V>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kikUWO>DC_CX[]X	G@F]ZStsx{vuxgokkGWRkBYEVDGkUNk ikUWRUXGQZAXX >]Rsx{vuxgokkGWRkUAU[DUV]kWkiDC_CX[]XXSDQk^Y[_N[  		RUXGQG\UVG@YL^S	@FAQ>I>IQXGQ]R>sx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BRS^]Q]]ZB@[U			RUXGQ>sx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEMNENDELUZDQD^Z\B>O>\QRC\DQUQE^	@FAQ>I>>>RSLABZDC_D	RUXGQ>>]RSWUPDSZ]DM_CkCO>>]R>>sx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXUNENDELUZDQD^Z\B>HHsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ NENDELUZDQD^Z\B>HHsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[UNENDELUZDQD^Z\B>RSLABZDC_D	@FAQ>I>]RAABNkQ[GUBYQYV^WZSUG\UVG@YL^SRSLABZDC_D\QRC\DQUQE^FQ@AFZ>MU@EAYG\ZX EBM^V	>ZFR GB^_Z	NENDELUZDQD^Z\B>]RAABNkQ[GO>>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iYLW ^L@NNENDELUZDQD^Z\BWk FRQ][SW[]MU@EAYG\ZX EBM^V	sx{vuxgokkGWRkP P\XE _DFNAk ihZWk FRQ][SW[]oi>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[UNENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[UZFR GB^_ZO>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iU_GSMD@VZFR GB^_ZN\BV[\CPZBP _LMU@EAYG\ZX EBM^V	hZsx{vuxgokkGWRkP P\XE _DFNAk ihZN\BV[\CPZBP _Loi>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@VZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>>I>>>I>\_]CCVGPZ_[	RS^]Q]]ZB@[U>]RUBYQYV^WZSUsx{vuxgokkGWRkUQ Y]ZXWDki\_]CCVGPZ_[ZFR GB^_ZO>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[U \_]CCVGPZ_[C[Q BXUC[Q BXUPQR]ZQcdk`qydkp}fPQR]ZQPcdkw{z`qz`kp}fcdkw{z`qz`kp}fuvgdu`|CDW[Z@QZ@GWk@YDhZZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>I>]RG\UVG@YL^Ssx{vuxgokkGWRkUQ Y]ZXWDki\_]CCVGPZ_[ZFR GB^_ZO>>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXU \_]CCVGPZ_[RS^]Q]]ZB@[UC[Q BXUPQR]ZQcdkwuw|q@FAQgwkcwhZZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>>>IQXGQ]R\QRC\DQUQE^O>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@V \_]CCVGPZ_[RS^]Q]]ZB@[UYLW ^L@NPQR]ZQcdkwuw|q@FAQgwkcwhZZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>I>]RRSLABZDC_DO>>>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@NZFR GB^_Z>>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U \_]CCVGPZ_[RS^]Q]]ZB@[UZFR GB^_ZO>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ \_]CCVGPZ_[XSDQk^Y[_N[ C[Q BXUPQR]ZQcdkpqvas@FAQhZPQR]ZQcdkpqvaskx{s@FAQhZPQR]ZQcdkpqvaskp}gdxumRUXGQhZZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZFQ@AFZ>I>I>]RZFR GB^_Z			NENDELUZDQD^Z\BFQ@AFZ>]RM[YQk NNVYMFB\ZFR GB^_ZFQ@AFZ>]R\QRC\DQUQE^sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tADPU@Qk[D@][ZYLW ^L@NNWCUNEM >]RG\UVG@YL^SMRFkUDFEFUZ@WS\XZ[QkNENDELUZDQD^Z\BO>>[]\CNNBEZB[Q\APGNWCUNEMU_GSMD@V>ZFR GB^_Z	sx{vuxgokkGWRkWBQASY @NZRk iNWCUNEM\_]CCVGPZ_[NWCUNEM U_GSMD@VZFR GB^_Z>]Rsx{vuxgokkGWRkCGC  VMVVk iZFR GB^_ZHHZFR GB^_Z			NENDELUZDQD^Z\BFQ@AFZ>]RM[YQk NNVYMFB\ZFR GB^_ZFQ@AFZ>>>>I>R\SMNMEZYDUUQY	tR]XQDQFYG@WS\XZ[Qk>R\SMNMEZYDUUQY	R\SMNMEZYDUUQY			RUXGQLLQR\SMNMEZYDUUQY>PXXE]UPNN	tsx{vuxgokkGWRkUMX_NCYCki@WS\XZ[Qk>AYZ]RZWU_ADX	tsx{vuxgokkGWRkBYEVDGkUNk i@WS\XZ[Qk>]Rsx{vuxgokkGWRkCGC  VMVVk iAYZ]RZWU_ADXHHAYZ]RZWU_ADX		NENDELUZDQD^Z\BO>>>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UNWCUNEM>FQ@AFZ>I>AZGQ@AYZ]RZWU_ADX>_S_kVQNAB\A	tsx{vuxgokkGWRkW[_VWkXXkisx{vuxgokkGWRkWLGRkXNMY[ki@WS\XZ[QkXSDQk^Y[_N[ >>>>]R_S_kVQNAB\A			RUXGQFQ@AFZ>>>>]Rtsx{vuxgokkGWRk_GUYNZVVVk i_S_kVQNAB\AZFR GB^_Z		sx{vuxgokkGWRkD@WYYENNCMMkkiZFR GB^_ZO>tsx{vuxgokkGWRkSXVSWM_EQki_S_kVQNAB\A>FQ@AFZ>I>tsx{vuxgokkGWRkWWGZMMY]kRW^ki_S_kVQNAB\AR\SMNMEZYDUUQY>]Rtsx{vuxgokkGWRkX QBXDFYNZBk i_S_kVQNAB\A@WS\XZ[QkO>tsx{vuxgokkGWRkSXVSWM_EQki_S_kVQNAB\A>FQ@AFZ>>I>>]RPXXE]UPNNtsx{vuxgokkGWRkABFEYZ\]WX]@ki@WS\XZ[QkPXXE]UPNN>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nt[DWUW\Qk]ZBUX]PU@Q@WS\XZ[Qk@FAQ>>>>]RG\UVG@YL^S]__CZGUREPA@SB^@WS\XZ[Qk>]RG\UVG@YL^SHH\QRC\DQUQE^sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtPQXQ@Qk[D@][ZRS^]Q]]ZB@[U>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iXSDQk^Y[_N[ MU@EAYG\ZX EBM^VMXGXZZXN\W SXO>>>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk iMXGXZZXN\W SXoiUG]XFZSDM]O>]Rsx{vuxgokkGWRkUAU[DUV]kWki]XFZSDM]YLW ^L@N			tsx{vuxgokkGWRk@Y@R NPPDCC@ki]XFZSDM]tsx{vuxgokkGWRkSXVSWM_EQki]XFZSDM]>>I>I>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nsx{vuxgokkGWRk\XL[WSGSNNWk  iXSDQk^Y[_N[ MU@EAYG\ZX EBM^V@N\C\ kUNPO>>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk i@N\C\ kUNPoiUG]QAX_LO>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U]QAX_LtPQXQ@Qk[D@][Z]QAX_L>I>I>I>>RAZW@][ZNR_YVD[NE]_C[SMX>O>]RPQR]ZQPYLW ^L@NFQ@AFZ>>>>L[[[@A\F@_ 	PQR]ZQPU_GSMD@Vcdyakdxas}zkp}fcdkw{z`qz`kp}fNWCUNEM >ZC@ @[S@[BZ_M	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>]Rtsx{vuxgokkGWRkY  PFNk iL[[[@A\F@_ R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiL[[[@A\F@_ YLW ^L@NUGSBUEZADVUEU^ZC@ @[S@[BZ_Moi	SBUEZADVUEU^>]RPQR]ZQPC[Q BXUtsx{vuxgokkGWRkY  PFNk icdkdxas}zkp}fR[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkicdkdxas}zkp}fRS^]Q]]ZB@[UUGSBUEZADVUEU^ZC@ @[S@[BZ_Moi	SBUEZADVUEU^>I>>>SkZ[WXDRN@	PQR]ZQPYLW ^L@N  uvgdu`|>AUSF]VSASR]A\U	cdkw{z`qz`kp}fYLW ^L@N sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiSkZ[WXDRN@U_GSMD@VjXSDQk^Y[_N[ sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiSkZ[WXDRN@NWCUNEMC[Q BXU>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiAUSF]VSASR]A\UZC@ @[S@[BZ_Moi	AUSF]VSASR]A\U>R[FQUW\ZC@ @[S@[BZ_MUGSBUEZADVUEU^O>PXXE]UPNN	tsx{vuxgokkGWRkUMX_NCYCkiSBUEZADVUEU^>>]RPXXE]UPNNHHPXXE]UPNN		 O>C]_YNUWVZ	tsx{vuxgokkGWRkDNNU_UYWXVVkiSBUEZADVUEU^>>]RC]_YNUWVZHHC]_YNUWVZ HHC]_YNUWVZ
  W[Z@]ZAQ>>>I>]]RB__ZRRX	tsx{vuxgokkGWRkC]YQRGZkiSBUEZADVUEU^>>SkYVANG	tsx{vuxgokkGWRkC]YQRGZkiR^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkCGC  VMVVk i]]RB__ZRRXsx{vuxgokkGWRkCGC  VMVVk iSkYVANG]]RB__ZRRX			SkYVANGW[Z@]ZAQ>N_QFQSGPkGSL]	tsx{vuxgokkGWRkBYEVDGkUNk iSBUEZADVUEU^RUXGQZAXX   >^QGALDUWM	ZAXX>]Rsx{vuxgokkGWRkCGC  VMVVk iN_QFQSGPkGSL]sx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXU N_QFQSGPkGSL]V\AWN]GBZ@^QGALDUWM	V\AWN]GBZ@oi>QXGQ]RkACM_XP_VCUZ YkLSBUEZADVUEU^LP ULQ^QGALDUWM	YLW ^L@N>]R^QGALDUWM			ZAXXHHBQFG][ZkW[YDUFQ^QGALDUWMXCDS]V]N]\U[DX CW[Z@]ZAQ>>>>YX@]NWDSU	Z]ELLM]_XSBWGQSBUEZADVUEU^>>>>]RYX@]NWDSU			RUXGQO>>[]\CNNBEZB[Q\APGC[Q BXUNWCUNEMsx{vuxgokkGWRkQANE SG_kXV\kiSBUEZADVUEU^>W[Z@]ZAQ>I>]RYX@]NWDSU			@FAQO>]R]]EN_BYRS]UBkSBUEZADVUEU^SBUEZADVUEU^C[Q BXUO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ t[DWUW\Qk]ZBUX]PU@QSBUEZADVUEU^@FAQ>IQXGQ]RSQNV[\]PPZUSBUEZADVUEU^G[V]FSPk\ Z]^AB_PSBUEZADVUEU^O>>>CBZR\RDFU\DVGMSkGSBUEZADVUEU^>Q^YGW\LCNk[ZNSBUEZADVUEU^>I>tsx{vuxgokkGWRkSXVSWM_EQkisx{vuxgokkGWRkWLGRkXNMY[kiSBUEZADVUEU^XSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiSBUEZADVUEU^YLW ^L@N>W[Z@]ZAQ>I>]RSQNV[\]PPZUSBUEZADVUEU^G[V]FSPk\ Z]^AB_PSBUEZADVUEU^O>CBZR\RDFU\DVGMSkGSBUEZADVUEU^>Q^YGW\LCNk[ZNSBUEZADVUEU^>I>FENRYEVF@SSASA\C\ZPSBUEZADVUEU^>I>A] LR\DNSRGW[[>G[XMQ@QLRDLMCX 	cdkw{z`qz`kp}fNWCUNEM>]Rtsx{vuxgokkGWRkY  PFNk iG[XMQ@QLRDLMCX sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiG[XMQ@QLRDLMCX XSDQk^Y[_N[ UG\\^WNCFGO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki\\^WNCFGHHtsx{vuxgokkGWRk_XXP] C^Mk i\\^WNCFGW[Z@]ZAQ>>>>\YC]ZCSV	tsx{vuxgokkGWRkDNNU_UYWXVVki\\^WNCFG>]R\YC]ZCSVHH\YC]ZCSV
 W[Z@]ZAQ>E[V@QkBM	tsx{vuxgokkGWRkBYEVDGkUNk i\\^WNCFG>]Rsx{vuxgokkGWRkCGC  VMVVk iE[V@QkBMW[Z@]ZAQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMXSDQk^Y[_N[ 			RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMXSDQk^Y[_N[ 			RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiE[V@QkBMXSDQk^Y[_N[ 			RUXGQW[Z@]ZAQ>]RRXSR@NGUZE[V@QkBMW[Z@]ZAQ>SSCXSG@ZEDL	GCUPYVB\DZUAAE[V@QkBM>>>]Rsx{vuxgokkGWRkCGC  VMVVk iSSCXSG@ZEDLSSCXSG@ZEDL		E[V@QkBMO>^EQW_ZP\[\_^S^\\^WNCFGSSCXSG@ZEDL>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nt[DWUW\Qk]ZBUX]PU@Q\\^WNCFG@FAQ>I>I>I>UNkWNUFRUR^]G^QMP cdkw{z`qz`kp}fNWCUNEM>UNkWNUFRUR^]G^QMP cdkw{z`qz`kp}fU_GSMD@V>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UO>>k[Z	SL@D ]FAVZuvgdu`|U_GSMD@Vj>EVFk_ YZX	tSQ@k[D@][Zk[Z>]Rsx{vuxgokkGWRkCGC  VMVVk iEVFk_ YZXEVFk_ YZX		O>Y@kYS ZBZ	sx{vuxgokkGWRkWBDQ[VVAZE\kiEVFk_ YZX@FAQ>]Rsx{vuxgokkGWRkCGC  VMVVk iY@kYS ZBZS]^CLWANUZY@kYS ZBZtPQXQ@Qk[D@][Zk[Z>I>[L]@kCM^R	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMM_E@QREC][XSDQk^Y[_N[ >]Rsx{vuxgokkGWRkCGC  VMVVk i[L]@kCM^R[L]@kCM^R		sx{vuxgokkGWRkD@WYYENNCMMkki[L]@kCM^R
LWLRHHsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VXABG]WV@AL\[L]@kCM^RHH_AX kFk \XUULFZ[L]@kCM^RO>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VYSWP_GN@FXXC[Q BXUU_GSMD@V >I>I>I>RAZW@][ZNAGECUZEWRLU VXW>O>@FMO>>]RPQR]ZQPNWCUNEM  FQ@AFZ>]RQYD@Msx{vuxgoU_GSMD@ViO>sx{vuxgoU_GSMD@Vi	>[]\CNNBEZB[Q\APGYLW ^L@NC[Q BXU>I>>]RQYD@Msx{vuxgoNWCUNEMiFQ@AFZ>sx{vuxgoNWCUNEM i	@FAQ>]R]GGQ@ksq`oNWCUNEM isx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>BD_BM\ SNNREV	tSQ@k[D@][ZXSDQk^Y[_N[ UFFUM>PMZ\QGUWRU	RUXGQ>>]Rsx{vuxgokkGWRkWBSB\_k iBD_BM\ SNNREVO>]RQYD@MBD_BM\ SNNREVo@iPMZ\QGUWRU	@FAQ>]RPMZ\QGUWRUQYD@MBD_BM\ SNNREVoU_GSMD@Visx{vuxgokkGWRkWBSB\_k iBD_BM\ SNNREVoYLW ^L@NiO>R[FQUW\BD_BM\ SNNREVoU_GSMD@ViUGkW]O>]Rsx{vuxgokkGWRkWBSB\_k ikW]QYD@MkW]oDiO>PMZ\QGUWRU	@FAQ>VFQU_>>>I>>>>I>I>>I>]RPMZ\QGUWRUsx{vuxgokkGWRkA[^M[ DkiU_GSMD@V >I>>>]RV@  NBWM[ML[CR^N]SFX^UDZ^SGFZFQ@AFZ>CDGDBR^PPMR	sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U]Z@SQ@k[D@][ZXSDQk^Y[_N[ >]RCDGDBR^PPMRsx{vuxgokkGWRkNWYM^SkLZ[BNkiHHCDGDBR^PPMR
sx{vuxgokkGWRkNWYM^SkLZ[BNkiO>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NtADPU@Qk[D@][ZRS^]Q]]ZB@[Usx{vuxgokkGWRkNWYM^SkLZ[BNki>NR_YVD[NE]_C[SMX>I>AZGQ@CDGDBR^PPMR>VFk\E[[BAL]CZR^N]SFX^UDZ^SGFZXCDS]V]N]\U[DX C>]RBZVkBZC[SWGQO>L\XXZD _ZkZ >AYAB LSXGWVRFMk]WA>FQ@AFZ>I>M YGAF^PE@ZQB	AEZGREWF[>DQVLCCAW^S_B	UFFUM>R^N]SFX^UDZ^SGFZ>>>M YGAF^PE@ZQBRS^]Q]]ZB@[U>>UY@NLDA	VVURPkXWXC_@LA\>R[FQUW\UY@NLDAUG[S^PZMYVR\RPO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki[S^PZMYVR\RPDQVLCCAW^S_Boi	[S^PZMYVR\RP>I>>>BB@kB_PGF	UFFUM>LVFZYDE	AQ_^@\LQBMLA[XS>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiLVFZYDEoiBB@kB_PGFoXSDQk^Y[_N[ LVFZYDEoii	U_GSMD@VLVFZYDEoi>MQYYUZ	tSQ@k[D@][ZYLW ^L@NUFFUM>]Rsx{vuxgokkGWRkWBSB\_k iMQYYUZMQYYUZ	UFFUM>EDE_X[\L]^	RUXGQ>R[FQUW\DQVLCCAW^S_BUGDCPZkSGSNUNO>>>>]\BRNLGVMDF\Q	tsx{vuxgokkGWRkAU^WLA[XZYQAkiDCPZkSGSNUN>>>>WRA[@SF\ZPSB	]\BRNLGVMDF\Q]\BRNLGVMDF\QoYLW ^L@NiH]\BRNLGVMDF\QoYLW ^L@Ni>]ZUL[FWQk@A	]GGQ@MQYYUZoDCPZkSGSNUNiMQYYUZoDCPZkSGSNUNi>]RWRA[@SF\ZPSB			]ZUL[FWQk@AW[Z@]ZAQ>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEM ]ZUL[FWQk@AYF WAZXM]sx{vuxgokkGWRkQDZV_ki]ZUL[FWQk@Asx{vuxgokkGWRkD@WYYENNCMMkkiYF WAZXM]oi			WRA[@SF\ZPSBsx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@YF WAZXM]oi W[Z@]ZAQ>EDE_X[\L]^	@FAQ>VFQU_>I>]REDE_X[\L]^O>R[FQUW\BB@kB_PGFUG_QM	
NkUQN V_FO>WRA[@SF\ZPSB	\[A_REFDP]C@_Zsx{vuxgokkGWRkQDZV_ki_QMNkUQN V_F>]ZUL[FWQk@A	]GGQ@MQYYUZo_QMiMQYYUZo_QMi>]RWRA[@SF\ZPSB			]ZUL[FWQk@AW[Z@]ZAQ>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@N ]ZUL[FWQk@AYF WAZXM]sx{vuxgokkGWRkQDZV_ki]ZUL[FWQk@Asx{vuxgokkGWRkD@WYYENNCMMkkiYF WAZXM]oi			WRA[@SF\ZPSBsx{vuxgokkGWRkNWYM^SkLZ[BNki]Z@YF WAZXM]oi  W[Z@]ZAQ>EDE_X[\L]^	@FAQ>VFQU_>I>I>>^ZF\WFSVE[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[ >EY\BBGk UQR	M YGAF^PE@ZQBXSDQk^Y[_N[ ^ZF\WFSVE[^ZF\WFSVE[C[Q BXU>\@XCQZ^[F	FXR_kP\UNPSM>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiEY\BBGk UQRHH]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiEY\BBGk UQR  EDE_X[\L]^	@FAQ>]R\@XCQZ^[F		tsx{vuxgokkGWRk@Y@R NPPDCC@ki\@XCQZ^[FEDE_X[\L]^	@FAQ>>>]REDE_X[\L]^sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VO>XL\@[@VUX_NAEW	^ZF\WFSVE[^ZF\WFSVE[XSDQk^Y[_N[ >^@RNW_]kVSNAU	SQ@k[D@][ZNWCUNEMUFFUM>]Rsx{vuxgokkGWRkWBSB\_k i^@RNW_]kVSNAUHHsx{vuxgokkGWRkUFBG[ZLZN Gk iXL\@[@VUX_NAEW^@RNW_]kVSNAU@FAQEDE_X[\L]^	@FAQ>I>]REDE_X[\L]^FQ@AFZ>AD^QPCSV	sx{vuxgokkGWRkNWYM^SkLZ[BNki>SGVFEFV	>@^UYFRU^_NFV^	>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>ZA[BEY]	tSQ@k[D@][ZU_GSMD@V>>>]Rsx{vuxgokkGWRkCGC  VMVVk iZA[BEY]sx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEMZA[BEY]Wk FRQ][SW[]O>SGVFEFV	]Z@Wk FRQ][SW[]oi>>>@^UYFRU^_NFV^	]Z@Wk FRQ][SW[]oi>I>>>>I>ZYGQLVXY	@^UYFRU^_NFV^	@^UYFRU^_NFV^			 @^UYFRU^_NFV^			>]RSGVFEFV
AD^QPCSVSGVFEFVZYGQLVXYFQ@AFZ>>>>]RPZEURB[UWFUPXSDQk^Y[_N[  FQ@AFZ>@FMO>SLXEXL ZZA^Y>\BW^]C W]NPM>>AYAB LSXGWVRFMk]WA>XGQUVSENX[NNVPU\F>\XkSZUYS\_N>L\XXZD _ZkZ >ZP_kQXYW_>BBUkARVP\@R\FWS>QSVVES@BPSM	S^\_D[RDVZ\R@UZk>Q@_N^]QCAYkR	CQQ_Y@  PLSE@G>EDYGXEDDXQ	tsx{vuxgokkGWRk@Y@R NPPDCC@kiEY\BBGk UQRHH]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiEY\BBGk UQR HH\@XCQZ^[F		tsx{vuxgokkGWRk@Y@R NPPDCC@ki\@XCQZ^[F>>>]REDYGXEDDXQtsx{vuxgokkGWRk@Y@R NPPDCC@kiM YGAF^PE@ZQBYLW ^L@NEDYGXEDDXQ	@FAQ>>]REDYGXEDDXQsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>>XL\@[@VUX_NAEW	^ZF\WFSVE[^ZF\WFSVE[U_GSMD@V>^@RNW_]kVSNAU	SQ@k[D@][ZXSDQk^Y[_N[ UFFUM>]Rsx{vuxgokkGWRkWBSB\_k i^@RNW_]kVSNAUHHsx{vuxgokkGWRkUFBG[ZLZN Gk iXL\@[@VUX_NAEW^@RNW_]kVSNAU@FAQEDYGXEDDXQ	@FAQ>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtADPU@Qk[D@][ZYLW ^L@NAD^QPCSVHEDYGXEDDXQ@^UYFRU^_NFV^RS^]Q]]ZB@[U >RQ^P_ZLZLBC	UFFUM>R[FQUW\DQVLCCAW^S_BUGDCPZkSGSNUNO>Q_DXXPAY	DCPZkSGSNUN			M YGAF^PE@ZQBRS^]Q]]ZB@[UQSVVES@BPSMHHsx{vuxgokkGWRkQDZV_kiDCPZkSGSNUNLUL 			YLW ^L@NQ@_N^]QCAYkR>]\BRNLGVMDF\Q	tsx{vuxgokkGWRkAU^WLA[XZYQAkiDCPZkSGSNUN>]R]\BRNLGVMDF\QO>RQ^P_ZLZLBCoDCPZkSGSNUNi	]\BRNLGVMDF\QoNWCUNEMiH]\BRNLGVMDF\QoU_GSMD@ViQ_DXXPAYNWCUNEMsx{vuxgokkGWRkNWYM^SkLZ[BNki>I>I>R[FQUW\BB@kB_PGFUG_QM	
NkUQN V_FO>PVVDNU^Z 	\[A_REFDP]C@_Zsx{vuxgokkGWRkQDZV_ki_QM NkUQN V_F>]RPVVDNU^Z 			HHsx{vuxgokkGWRkQDZV_kiPVVDNU^Z 			U_GSMD@VPVVDNU^Z 	C[Q BXUsx{vuxgokkGWRkNWYM^SkLZ[BNki>RQ^P_ZLZLBCo_QMi	PVVDNU^Z >>>I>tADPU@Qk[D@][ZU_GSMD@VRQ^P_ZLZLBCYLW ^L@N >>>IR]ZUXXMO>L^U[US^\kM^XSDQk^Y[_N[  >>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>>>RAZW@][Z\[A_REFDP]C@_ZDCPZkSGSNUNNkUQN V_F>O>>>]\BRNLGVMDF\Q	tsx{vuxgokkGWRkAU^WLA[XZYQAkiDCPZkSGSNUN>]R]\BRNLGVMDF\QFQ@AFZ>WRA[@SF\ZPSB	]\BRNLGVMDF\QoNWCUNEMiH]\BRNLGVMDF\QoU_GSMD@Vi>]R]\BRNLGVMDF\QoRS^]Q]]ZB@[Ui
 FQ@AFZU_GSMD@V WRA[@SF\ZPSB>>>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>FQ@AFZWRA[@SF\ZPSBHsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\Bsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BNkUQN V_F		RUXGQ>>>I>RAZW@][ZS@\GEX]BVBD M>O>kDB	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VSQ@k[D@][ZU_GSMD@V>kNSBV^C>CBSBMX_BM	sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMSQ@k[D@][ZYLW ^L@N>]RCBSBMX_BM			kDBO>SX[VUXCDPV>]Rsx{vuxgokkGWRk@L\SQY@ZAkiCDPVsx{vuxgokkGWRkUU\RUWEQkiCDPVNWCUNEMsx{vuxgokkGWRkCGC  VMVVk ikDBkDB		]GGQ@CDPV
[D@][ZGO>>tCDPV
EAQFMCDPV
DFQDUFQphL xqhL hL rf{yOCDPV
[D@][ZGIc|hL fqhLRhL@][ZkhLQUYQ	GWkhLQhLQP]ZSk]hLQBhLXhLPhL@QuzhL  [D@hL[ZkBUXAQ	hLkDB>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>tCDkWUW\QkPQXQ@QYLW ^L@NU_GSMD@V>tCDkWUW\QkPQXQ@QU_GSMD@VYLW ^L@N>>>>I>IQXGQO>>tPQXQ@Qk[D@][ZYLW ^L@N>I>I>>>I>RAZW@][ZkNSBV^C>O>@FMO>]RPQR]ZQPC[Q BXU  FQ@AFZ>M YGAF^PE@ZQB	AEZGREWF[>L \DERMNRVW	GM_EAV^VFW>XDN^VABEUF	SL@D ]FAVZuvgdu`|YLW ^L@N jRS^]Q]]ZB@[U>MF[_[DUBUF	SL@D ]FAVZuvgdu`|YLW ^L@N jRS^]Q]]ZB@[U>W\LAYYW\WAXY	SL@D ]FAVZuvgdu`|XSDQk^Y[_N[ L L XSDQk^Y[_N[ >VEMC@@GXQ@	SL@D ]FAVZuvgdu`|XSDQk^Y[_N[ RS^]Q]]ZB@[U>[SG]QZM @Q	SL@D ]FAVZuvgdu`|YLW ^L@N C[Q BXU>MBXQFUB\EF	XSDQk^Y[_N[ SL@D ]FAVZuvgdu`|Sj>NP]RCEUPVACP	UFFUM>M YGAF^PE@ZQBRS^]Q]]ZB@[U	
U_GSMD@V>M YGAF^PE@ZQBRS^]Q]]ZB@[U 	
YLW ^L@N>>>R[FQUW\NP]RCEUPVACPUGDCPZkSGSNUN	
DFQR]LO>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDCPZkSGSNUNW[Z@]ZAQ>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iDCPZkSGSNUN>>]RNENDELUZDQD^Z\B			RUXGQW[Z@]ZAQ>>>SLZ X_\F	XSDQk^Y[_N[ DFQR]LXSDQk^Y[_N[ DFQR]LYLW ^L@N>PM@^VE@UL ]Q	sx{vuxgokkGWRkWBQASY @NZRk iSLZ X_\FNENDELUZDQD^Z\B>]RPM@^VE@UL ]Q		NENDELUZDQD^Z\B^EQW_ZP\[\_^S^DCPZkSGSNUNPM@^VE@UL ]Q>I>\R_CQ_AQN	M YGAF^PE@ZQBYLW ^L@N>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki\R_CQ_AQNO>S_^E^XD	tsx{vuxgokkGWRkBYEVDGkUNk i\R_CQ_AQN>]Rsx{vuxgokkGWRkCGC  VMVVk iS_^E^XDS_^E^XD		O>>>>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@Nsx{vuxgokkGWRkQDZV_kiS_^E^XD HHsx{vuxgokkGWRkUAU[DUV]kWkiS_^E^XDC[Q BXU			O>>>>SUB\XXALLBWR W\F X\R_CQ_AQNLUL U>UC[WM Z \R_CQ_AQN>IQXGQO>[UD^WUGFBW	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ S_^E^XD>]Rsx{vuxgokkGWRkCGC  VMVVk i[UD^WUGFBW[UD^WUGFBW		S_^E^XD^EQW_ZP\[\_^S^\R_CQ_AQN[UD^WUGFBW>AZGQ@[UD^WUGFBW>I>I>AZGQ@S_^E^XD>>I>EFMUDkC]N	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZNWCUNEM>]EQDF_L_VYRM[	PQR]ZQPXSDQk^Y[_N[ cdkw{z`qz`kp}fC[Q BXUEFMUDkC]N>ZEX_RLMUM C	UFFUM>M YGAF^PE@ZQBXDN^VABEUF>>>>M YGAF^PE@ZQBMF[_[DUBUF>M YGAF^PE@ZQBW\LAYYW\WAXY>L \DERMNRVWVEMC@@GXQ@>L \DERMNRVW[SG]QZM @Q>L \DERMNRVWMF[_[DUBUF>L \DERMNRVWW\LAYYW\WAXY>EFMUDkC]NVEMC@@GXQ@>>>EFMUDkC]N[SG]QZM @Q>EFMUDkC]NMF[_[DUBUF>EFMUDkC]NW\LAYYW\WAXY>]EQDF_L_VYRM[VEMC@@GXQ@>]EQDF_L_VYRM[[SG]QZM @Q>]EQDF_L_VYRM[MF[_[DUBUF>]EQDF_L_VYRM[W\LAYYW\WAXY>>W VNCSF N	AQ_^@\LQBMLA[XS>ZEX_RLMUM Coi	W VNCSF Noi>ZEX_RLMUM Coi	W VNCSF NoiU_GSMD@V >>AZGQ@W VNCSF N>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiM YGAF^PE@ZQBC[Q BXUXDN^VABEUFUGVFNZDQD W_ZEX_RLMUM Coi	VFNZDQD W_>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiM YGAF^PE@ZQBU_GSMD@VXDN^VABEUFUGVFNZDQD W_ZEX_RLMUM Coi	VFNZDQD W_>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiuvgdu`|C[Q BXUMBXQFUB\EFRS^]Q]]ZB@[UUG[kC] AkZEX_RLMUM Coi	[kC] Ak>>>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiM YGAF^PE@ZQBMBXQFUB\EFNWCUNEMUG[kC] AkZEX_RLMUM Coi	[kC] Ak>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiL \DERMNRVWMBXQFUB\EFRS^]Q]]ZB@[U UG[kC] AkZEX_RLMUM Coi	[kC] Ak>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkiEFMUDkC]NMBXQFUB\EFNWCUNEM UG[kC] AkZEX_RLMUM Coi	[kC] Ak>>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVki]EQDF_L_VYRM[MBXQFUB\EFC[Q BXU UG[kC] AkZEX_RLMUM Coi	[kC] Ak>I>C@Nk[R	SL@D ]FAVZuvgdu`|SLL>>[UXR XRYS	UFFUMuvgdu`|XSDQk^Y[_N[  M YGAF^PE@ZQBL \DERMNRVWEFMUDkC]N]EQDF_L_VYRM[>R[FQUW\[UXR XRYSUGkSPO>]Rtsx{vuxgokkGWRkY  PFNk ikSPtsx{vuxgokkGWRk_XXP] C^Mk ikSP_ W^\V CPNY_kSPC[Q BXUC@Nk[RXCDS]V]N]\U[DX CYLW ^L@N >I>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>R[FQUW\[UXR XRYSUGkSPO>R[FQUW\UFFUMRS^]Q]]ZB@[U YLW ^L@N XSDQk^Y[_N[   NWCUNEM YLW ^L@N C[Q BXU XSDQk^Y[_N[  XSDQk^Y[_N[  C[Q BXUUGG_PE@ M@LMP_O>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkikSPG_PE@ M@LMP_UGRVANBWSZBZEX_RLMUM Coi	RVANBWSZB>I>R[FQUW\UFFUMtsx{vuxgokkGWRkV^E_YEEGLMVkikSPC[Q BXUUGNVBZBNARBELZEX_RLMUM Coi	NVBZBNARBEL>I>>>I>AZGQ@C@Nk[R[UXR XRYSkSPG_PE@ M@LMP_RVANBWSZBNVBZBNARBEL>>>>>LWDQUBQQRS^CNVD	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBRS^]Q]]ZB@[Usx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZU_GSMD@Vsx{vuxgokkGWRkDMF\VYFZMkiL \DERMNRVWC[Q BXUsx{vuxgokkGWRkDMF\VYFZMkiEFMUDkC]NNWCUNEMsx{vuxgokkGWRkDMF\VYFZMki]EQDF_L_VYRM[RS^]Q]]ZB@[U>]RPQR]ZQPXSDQk^Y[_N[  LWDQUBQQRS^CNVDoi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fNWCUNEM>\CC[\ZAk\MY	UFFUM>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk iLWDQUBQQRS^CNVDUGkDPO>\CC[\ZAk\MYoi	kDPMF[_[DUBUF>\CC[\ZAk\MYoi	kDPW\LAYYW\WAXY>\CC[\ZAk\MYoi	kDPXSDQk^Y[_N[ W\LAYYW\WAXY>I>AZGQ@LWDQUBQQRS^CNVDkDP>R[FQUW\\CC[\ZAk\MYUGDBSVUEk^O>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDBSVUEk^QNDFDLWZkF@@LXFADBSVUEk^ZAXX>I>AZGQ@DBSVUEk^>_PQWSZ^V	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|RS^]Q]]ZB@[U>]RPQR]ZQPRS^]Q]]ZB@[U _PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fRS^]Q]]ZB@[U>>_PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBNWCUNEM>>_PQWSZ^Voi	sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>ZEASP^XC]BMVW	UFFUM>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk i_PQWSZ^VUGAAVRFMFUVZEASP^XC]BMVWoi	AAVRFMFUVNWCUNEM>>>>AZGQ@_PQWSZ^VAAVRFMFUV>R[FQUW\ZEASP^XC]BMVWUGDZ_]AXZkPO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiDZ_]AXZkPW[Z@]ZAQ>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iDZ_]AXZkP>]RNENDELUZDQD^Z\Bsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BRS^]Q]]ZB@[U		RUXGQO>NENDELUZDQD^Z\B	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXUsx{vuxgokkGWRkFSCP[[U^kiMF[_[DUBUFU_GSMD@VhZNENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BO>NENDELUZDQD^Z\B	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXU sx{vuxgokkGWRkFSCP[[U^kiMF[_[DUBUFYLW ^L@NhZNENDELUZDQD^Z\B>>I>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BO>NENDELUZDQD^Z\B	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@Vsx{vuxgokkGWRkFSCP[[U^kiMF[_[DUBUFYLW ^L@NhZNENDELUZDQD^Z\B>I>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\B^EQW_ZP\[\_^S^DZ_]AXZkPNENDELUZDQD^Z\B>I>I>>>>RLEMPN X^PNPY__	uvgdu`|U_GSMD@V>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRLEMPN X^PNPY__O>\FSWCA M[C@ 	sx{vuxgokkGWRkWLGRkXNMY[kiuvgdu`|RS^]Q]]ZB@[U >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki\FSWCA M[C@ RLEMPN X^PNPY__	\FSWCA M[C@ >I>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiRLEMPN X^PNPY__tsx{vuxgokkGWRk_XXP] C^Mk iRLEMPN X^PNPY__O>kCW	tsx{vuxgokkGWRkBYEVDGkUNk iRLEMPN X^PNPY__>]Rsx{vuxgokkGWRkCGC  VMVVk ikCWsx{vuxgokkGWRkUAU[DUV]kWkikCWU_GSMD@V		RUXGQO>EN_NW  _UQ 	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXUPQR]ZQcdkwuw|q@FAQhZkCW>>>]Rsx{vuxgokkGWRkCGC  VMVVk iEN_NW  _UQ EN_NW  _UQ 		kCWM[YQk NNVYMFB\EN_NW  _UQ O>kAZNFkMF DS	tsx{vuxgokkGWRkUMX_NCYCkiRLEMPN X^PNPY__>]R^EQW_ZP\[\_^S^RLEMPN X^PNPY__EN_NW  _UQ O>]RkAZNFkMF DStsx{vuxgokkGWRkABFEYZ\]WX]@kiRLEMPN X^PNPY__kAZNFkMF DS>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU tPQXQ@Qk[D@][ZRS^]Q]]ZB@[U>I>I>AZGQ@EN_NW  _UQ kAZNFkMF DS>I>AZGQ@kCW>>>>I>AZGQ@RLEMPN X^PNPY__\FSWCA M[C@ >[YFDADR]LW	sx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N tsx{vuxgokkGWRkQZNVM]LkiYLW ^L@NRUXGQ>]R[YFDADR]LWHH[YFDADR]LW			[YFDADR]LW	NWCUNEM>VEZ\QDkUZk	UFFUMsx{vuxgokkGWRkDMF\VYFZMkiuvgdu`|NWCUNEM>]RPQR]ZQPU_GSMD@V VEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkicdkw{z`qz`kp}fRS^]Q]]ZB@[U>VEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkiM YGAF^PE@ZQBXSDQk^Y[_N[ >VEZ\QDkUZkoi	sx{vuxgokkGWRkDMF\VYFZMkisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U>XYNGG^^A\S]P[U	UFFUM>>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk iVEZ\QDkUZkUGM\Xk@[E^AZXYNGG^^A\S]P[Uoi	M\Xk@[E^AZ[YFDADR]LW>>AZGQ@VEZ\QDkUZkM\Xk@[E^AZ>R[FQUW\XYNGG^^A\S]P[UUG^^FDR]VCUVW\O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki^^FDR]VCUVW\W[Z@]ZAQ>>>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk i^^FDR]VCUVW\>]RNENDELUZDQD^Z\Bsx{vuxgokkGWRkUAU[DUV]kWkiNENDELUZDQD^Z\BXSDQk^Y[_N[ 		RUXGQO>NENDELUZDQD^Z\B	sx{vuxgokkGWRkWBQASY @NZRk iU_GSMD@Vsx{vuxgokkGWRkFSCP[[U^kiW\LAYYW\WAXYYLW ^L@NNENDELUZDQD^Z\B>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\B^EQW_ZP\[\_^S^^^FDR]VCUVW\NENDELUZDQD^Z\B>>I>I>S@CkAW	sx{vuxgokkGWRkk\SZ\YY kiZEX_RLMUM C\CC[\ZAk\MY>N \VZA^Y	UFFUM>XWVRX[CWkB	RUXGQ>R[FQUW\sx{vuxgokkGWRkPE\P] W]XPFFAkiZEASP^XC]BMVWXYNGG^^A\S]P[UUG[BZVC\FDGFO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki[BZVC\FDGFW[Z@]ZAQ>>>_F]V@\	tsx{vuxgokkGWRkBYEVDGkUNk i[BZVC\FDGF>]Rsx{vuxgokkGWRkCGC  VMVVk i_F]V@\O>XWVRX[CWkB	@FAQ>W[Z@]ZAQ>I>]Rsx{vuxgokkGWRkUAU[DUV]kWki_F]V@\U_GSMD@V			RUXGQW[Z@]ZAQ>>]Rsx{vuxgokkGWRk\XL[WSGSNNWk  iYLW ^L@N_F]V@\YF WAZXM]O>>>R[FQUW\sx{vuxgokkGWRkPE\P] W]XPFFAkiYF WAZXM]oiYF WAZXM]oiYF WAZXM]oiUG]]RB__ZRRXO>]R]]RB__ZRRX		N \VZA^Yosx{vuxgokkGWRkQANE SG_kXV\ki]]RB__ZRRXi	@FAQ>>>>I>I>AZGQ@_F]V@\YF WAZXM]]]RB__ZRRX>I>]RXWVRX[CWkBO>R[FQUW\S@CkAWUG@WS\XZ[QkO>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WS\XZ[QkO>>>]R]GGQ@N \VZA^Yosx{vuxgokkGWRkQANE SG_kXV\ki@WS\XZ[QkiW[Z@]ZAQ>>SUB\XXALLBWR W\F X@WS\XZ[Qk>UC[WM Z @WS\XZ[Qk>I>I>I>AZGQ@N \VZA^YXWVRX[CWkB[BZVC\FDGF>R[FQUW\VVURPkXWXC_@LA\UGV@QV^ L]NA]GW^O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiV@QV^ L]NA]GW^HHtsx{vuxgokkGWRk_XXP] C^Mk iV@QV^ L]NA]GW^W[Z@]ZAQ>NENDELUZDQD^Z\B	tsx{vuxgokkGWRkBYEVDGkUNk iV@QV^ L]NA]GW^>]Rsx{vuxgokkGWRkCGC  VMVVk iNENDELUZDQD^Z\BO>>DC_SSQWSRU	E[BD@ER_  MBAZNENDELUZDQD^Z\BNWCUNEMNWCUNEM >>DC_SSQWSRU	E[BD@ER_  MBAZDC_SSQWSRUC[Q BXU NWCUNEM >]Rsx{vuxgokkGWRkCGC  VMVVk iDC_SSQWSRUDC_SSQWSRU		NENDELUZDQD^Z\B^EQW_ZP\[\_^S^V@QV^ L]NA]GW^DC_SSQWSRU>AZGQ@DC_SSQWSRU>>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>_QM	[]GP BDWEMGA\NERk>]R_QM		RUXGQO>CNBWM[	tsx{vuxgokkGWRkZZUG\R[XQk i_QMC>>>>]RCNBWM[O>tsx{vuxgokkGWRk@PUGSFAkFkiCNBWM[>tsx{vuxgokkGWRkUD[ F_GkkE\kiCNBWM[>I>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U O>SASXkDk  _	SL@D ]FAVZuvgdu`|YLW ^L@N>tPQXQ@Qk[D@][ZSASXkDk  _>BD_BM\ SNNREV	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VtSQ@k[D@][ZYLW ^L@NUFFUMUFFUM>>>]Rsx{vuxgokkGWRkWBSB\_k iBD_BM\ SNNREVO>]R]GGQ@BD_BM\ SNNREVoViUC[WM Z BD_BM\ SNNREVoVi>]R]GGQ@BD_BM\ SNNREVoU_GSMD@Visx{vuxgokkGWRkWBSB\_k iBD_BM\ SNNREVoYLW ^L@NiO>>>R[FQUW\BD_BM\ SNNREVoU_GSMD@ViUGkW]O>]Rsx{vuxgokkGWRkWBSB\_k ikW]]GGQ@kW]oViUC[WM Z kW]oVi>>>I>I>I>tPQXQ@Qk[D@][ZNWCUNEM>tPQXQ@Qk[D@][ZXSDQk^Y[_N[ >tPQXQ@Qk[D@][ZRS^]Q]]ZB@[U>tPQXQ@Qk[D@][ZXSDQk^Y[_N[ >tPQXQ@Qk[D@][ZYLW ^L@N>tPQXQ@Qk[D@][ZXSDQk^Y[_N[  >>tPQXQ@Qk[D@][ZNWCUNEM>tPQXQ@Qk[D@][ZNWCUNEM>AZGQ@BD_BM\ SNNREVkW]>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>tPQXQ@Qk@FUZG]QZ@U_GSMD@V>tPQXQ@Qk@FUZG]QZ@NWCUNEM>tPQXQ@Qk@FUZG]QZ@DPAZGEVRQCQ_>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>tCDkWXQUFkGW\QPAXQPk\[[_C[Q BXU>>>>tCDkWXQUFkGW\QPAXQPk\[[_YLW ^L@N>tCDkWXQUFkGW\QPAXQPk\[[_Y]BFFRNL@_MGA^>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>I>RAZW@][ZS^\_D[RDVZ\R@UZk>O>>@FMO>]RPQR]ZQPXSDQk^Y[_N[   FQ@AFZRUXGQ>M YGAF^PE@ZQB	AEZGREWF[>PYLQNRA^NB	M YGAF^PE@ZQBYLW ^L@N>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZNWCUNEM>Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]
 HHXABG]WV@AL\Rk[NLS^]HHM[YQk NNVYMFB\Rk[NLS^]FQ@AFZRUXGQ>>>>WAFFQZ@	tsx{vuxgokkGWRk\]XDEBSkWEkiPYLQNRA^NBtsx{vuxgokkGWRkBYEVDGkUNk iPYLQNRA^NB>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGU_GSMD@VC[Q BXU>FQ@AFZRUXGQ>I>>>>WAFFQZ@	^UNF\NZMLZLZkN[XAWAFFQZ@>NRU PPPEFXE	XCDS]V]N]\U[DX CSL@D ]FAVZuvgdu`|C[Q BXU>M MNEB\\BZFR	RS^]Q]]ZB@[UNRU PPPEFXERS^]Q]]ZB@[U >MFkYLAQVWkNk	RS^]Q]]ZB@[UNRU PPPEFXEYLW ^L@N >CZL\QE^BFPBU	SL@D ]FAVZuvgdu`|C[Q BXUL L >G@NG]LVUS]WW	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ CZL\QE^BFPBUXSDQk^Y[_N[  WAFFQZ@>C^kGDE	sx{vuxgokkGWRkUAU[DUV]kWkiG@NG]LVUS]WWRS^]Q]]ZB@[U		RUXGQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@M MNEB\\BZFR		RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@MFkYLAQVWkNk		RUXGQC^kGDEFQ@AFZ@FAQ>WAFFQZ@	sx{vuxgokkGWRkWBQASY @NZRk iC[Q BXUG@NG]LVUS]WW>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGYLW ^L@NYLW ^L@N>>FQ@AFZRUXGQ>I>BZ^GEBSkk\D^	WU^YMASDXk_GG>]RBZ^GEBSkk\D^FQ@AFZRUXGQ>\WXF^PSE	XSDQk^Y[_N[ sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkikMZ[W\L[YU[G@F]ZS^@U[FB_S@YGNYEL >YM BES ANU_	FG@C SM^kXMSMQR>U_GSMD@V >UFFUMkkgxaskkkkdxas}zkvugq kkkksaufpkzuyqkkkkbqfg}{zkk>UFFUMkMZ[W\L[YU[BZ^GEBSkk\D^\WXF^PSEXCDS]V]N]\U[DX C>>>>]RYM BES ANU_O>]R]Z@SQ@k[D@][ZYLW ^L@N
[]\CNNBEZB[Q\APGC[Q BXUU_GSMD@V>FQ@AFZRUXGQ>>I>WAFFQZ@	^UNF\NZMLZLZkN[XAWAFFQZ@>@GGQ\SRUZ\Y@	sx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@N YM BES ANU_>GG [ED[L kN	sx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@			>]RGG [ED[L kNO>]RESXMZQG @W_B@LWXk C[Q BXUO>[]\CNNBEZB[Q\APGYLW ^L@NYLW ^L@N>FQ@AFZRUXGQ>I>]RMRFkUDFEFUZPYLQNRA^NBWAFFQZ@O>[]\CNNBEZB[Q\APGU_GSMD@VU_GSMD@V>FQ@AFZRUXGQ>I>BNPPLF@kCX^GV[YFNZDXSDQk^Y[_N[ >IQXGQO>]RMRFkUDFEFUZPYLQNRA^NBO>>>[]\CNNBEZB[Q\APGNWCUNEMXSDQk^Y[_N[ >>FQ@AFZRUXGQ>I>>>I>AX\PUMENN\	SkBMPQQFSU WAFFQZ@M MNEB\\BZFRhZ@GGQ\SRUZ\Y@hZMFkYLAQVWkNk>]R^EQW_ZP\[\_^S^PYLQNRA^NBAX\PUMENN\O>FQ@AFZRUXGQ>I>]__CZGUREPA@SB^PYLQNRA^NB>>>RkV [kV DU^_PYLQNRA^NB>>>FQ@AFZ@FAQ>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>>>>FQ@AFZRUXGQ>>>I>>>>I>RAZW@][ZVVURPkXWXC_@LA\>O>\MkR ADAkL[S	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VFQ@AFZ\MkR ADAkL[S>NN^EXS[BQQLDWZ	PQR]ZQPXSDQk^Y[_N[  cdkw{z`qz`kp}fPQR]ZQPRS^]Q]]ZB@[U  uvgdu`|YLW ^L@NNWCUNEM >>>\[_WVZAZGWAk	G@F]ZStSQ@k[D@][ZC[Q BXU>]R\[_WVZAZGWAk		\MkR ADAkL[Soi	NN^EXS[BQQLDWZ\[_WVZAZGWAkRS^]Q]]ZB@[U>>[WCRCR\U 	G@F]ZStSQ@k[D@][ZNWCUNEM>]R[WCRCR\U 		[WCRCR\U 		\[_WVZAZGWAk\MkR ADAkL[Soi	NN^EXS[BQQLDWZ[WCRCR\U YLW ^L@N>FQ@AFZ\MkR ADAkL[S>I>>>>RAZW@][Z\VMNP D]CDEN^MPN\>O>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU ]GkYAX@]G]@Qsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>FQ@AFZUFFUMtSQ@kG]@Qk[D@][ZU_GSMD@VUFFUM>>I>FQ@AFZUFFUMtSQ@k[D@][ZU_GSMD@VUFFUM>I>RAZW@][Z@\DC@NG\kZ]R\MWV^AQVCCEY@>O>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM]GkYAX@]G]@Qsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VO>>>>tADPU@QkG]@Qk[D@][ZYLW ^L@NAQVCCEY@>FQ@AFZ>I>tADPU@Qk[D@][ZRS^]Q]]ZB@[UAQVCCEY@NWCUNEM>I>RAZW@][ZVLAFYQ]ZV[@kUCDCPZkSGSNUN>>O>AQVCCEY@	\VMNP D]CDEN^MPN\>FQ@AFZ]GGQ@AQVCCEY@oSL@D ]FAVZDCPZkSGSNUN i>I>>RAZW@][ZDZVSVQGL]XD\SADCPZkSGSNUN>O>AQVCCEY@	\VMNP D]CDEN^MPN\>>>>LC@\@MG@DGZ	sx{vuxgokkGWRkNWYM^SkLZ[BNkiLWPQLWQW>R[FQUW\AQVCCEY@UGWDWFFGG	
GLL][\B[\O>>]R]Z@GLL][\B[\LC@\@MG@DGZAZGQ@AQVCCEY@oWDWFFGGi>>I>AQVCCEY@oSL@D ]FAVZDCPZkSGSNUN i	sx{vuxgokkGWRkNWYM^SkLZ[BNki>@\DC@NG\kZ]R\MWV^AQVCCEY@>I>RAZW@][ZX[UP\PPBRNWB_k^RZUDCPZkSGSNUNAX\PUMENN\>O>]Rsx{vuxgokkGWRkCGC  VMVVk iAX\PUMENN\HHAX\PUMENN\			HHsx{vuxgokkGWRkD@WYYENNCMMkkiAX\PUMENN\
  FQ@AFZ>B\G]GSBE	sx{vuxgokkGWRkBG_ RDRGAkiC[Q BXUAX\PUMENN\>YLDSA@WDN	UFFUMtSQ@k[D@][ZYLW ^L@N UFFUM>CPF]\AUC	SL@D ]FAVZDCPZkSGSNUN>]R]GGQ@YLDSA@WDNoCPF]\AUCioC[Q BXUiYLDSA@WDNoCPF]\AUCioXSDQk^Y[_N[ i			B\G]GSBEFQ@AFZ>YLDSA@WDNoCPF]\AUCi	UFFUMU_GSMD@V	
sx{vuxgokkGWRkD@WYYENNCMMkkiAX\PUMENN\C[Q BXU	
B\G]GSBEYLW ^L@N	
sx{vuxgokkGWRkV\W][LkiAX\PUMENN\>tADPU@Qk[D@][ZYLW ^L@N YLDSA@WDNU_GSMD@V>I>RAZW@][ZWL\ BNLLYA@MU@kSDCPZkSGSNUN>O>YLDSA@WDN	UFFUMtSQ@k[D@][ZYLW ^L@NUFFUM>[GD[EZLN	]GGQ@YLDSA@WDNoSL@D ]FAVZDCPZkSGSNUNiYLDSA@WDNoSL@D ]FAVZDCPZkSGSNUNjiZAXX>]Rsx{vuxgokkGWRkWBSB\_k i[GD[EZLNHHQYD@M[GD[EZLNoYLW ^L@NiHHQYD@M[GD[EZLNoRS^]Q]]ZB@[UiHHQYD@M[GD[EZLNoYLW ^L@NiFQ@AFZRUXGQ>>^FX@FL[Mk_Q^	sx{vuxgokkGWRkWBDQ[VVAZE\ki[GD[EZLNoYLW ^L@Ni@FAQ>]Rsx{vuxgokkGWRkCGC  VMVVk i^FX@FL[Mk_Q^HHsx{vuxgokkGWRkD@WYYENNCMMkki^FX@FL[Mk_Q^		]Z@[GD[EZLNoC[Q BXUiFQ@AFZRUXGQ>]Rsx{vuxgokkGWRkBG_ RDRGAkiRS^]Q]]ZB@[U^FX@FL[Mk_Q^		[GD[EZLNoU_GSMD@ViFQ@AFZRUXGQ>]RM[YQk NNVYMFB\^FX@FL[Mk_Q^FQ@AFZRUXGQ>FQ@AFZ^FX@FL[Mk_Q^>I>RAZW@][ZWGUYPNQENN@V@QV^ L]NA]GW^WAFFQZ@>O>\BFMADBk_SQ	GCUPYVB\DZUAAWAFFQZ@>>>>]Rsx{vuxgokkGWRkCGC  VMVVk i\BFMADBk_SQHH\BFMADBk_SQ			FQ@AFZRUXGQ>>>@ZPBBBLkCRP G	GM_EAV^VFWNWCUNEMSL@D ]FAVZV@QV^ L]NA]GW^YLW ^L@N>>kQL	tsx{vuxgokkGWRk@Y@R NPPDCC@ki@ZPBBBLkCRP Gtsx{vuxgokkGWRkBYEVDGkUNk i@ZPBBBLkCRP GRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk ikQLHHkQL		\BFMADBk_SQO>]R^EQW_ZP\[\_^S^@ZPBBBLkCRP G\BFMADBk_SQFQ@AFZRUXGQ>kQL	tsx{vuxgokkGWRk@Y@R NPPDCC@ki@ZPBBBLkCRP Gtsx{vuxgokkGWRkBYEVDGkUNk i@ZPBBBLkCRP GRUXGQ>>>>]Rsx{vuxgokkGWRkCGC  VMVVk ikQLHHkQL		\BFMADBk_SQFQ@AFZRUXGQ>I>X[UP\PPBRNWB_k^RZUV@QV^ L]NA]GW^\BFMADBk_SQ>FQ@AFZ@FAQ>I>RAZW@][ZR^]PZ_k]k >O>@\DC@NG\kZ]R\MWV^UFFUM>>>>I>RAZW@][ZDLWR^\@\NCN\[E\>O>@FMO>]RPQR]ZQPYLW ^L@N  HHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UFQ@AFZ>>R[FQUW\VVURPkXWXC_@LA\UGBDNMA[LAAO>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiBDNMA[LAAtsx{vuxgokkGWRkDNNU_UYWXVVkiBDNMA[LAA
W[Z@]ZAQ>@ZPBBBLkCRP G	GM_EAV^VFWC[Q BXUSL@D ]FAVZBDNMA[LAAjC[Q BXU>YLDk_^F^	tsx{vuxgokkGWRk@Y@R NPPDCC@ki@ZPBBBLkCRP Gtsx{vuxgokkGWRkBYEVDGkUNk i@ZPBBBLkCRP GRUXGQ>]Rsx{vuxgokkGWRkCGC  VMVVk iYLDk_^F^HHYLDk_^F^			O>YLDk_^F^	WL\ BNLLYA@MU@kSBDNMA[LAA>]Rsx{vuxgokkGWRkCGC  VMVVk iYLDk_^F^YLDk_^F^		t^EQW_ZP\[\_^S^@ZPBBBLkCRP GYLDk_^F^>>I>]Rsx{vuxgokkGWRkCGC  VMVVk iYLDk_^F^HHYLDk_^F^			W[Z@]ZAQ>WXQUFG@U@WUW\Q@FAQBDNMA[LAA>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiBDNMA[LAAtsx{vuxgokkGWRkDNNU_UYWXVVkiBDNMA[LAA
W[Z@]ZAQ>]R^EQW_ZP\[\_^S^BDNMA[LAAYLDk_^F^O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U C[Q BXU>>>>DZVSVQGL]XD\SABDNMA[LAA>I>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGXSDQk^Y[_N[  [GD[EZLN>>>>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZCQQ_Y@  PLSE@G>O>>@FMO>]RPQR]ZQPC[Q BXUFQ@AFZRUXGQ>SB^VX\[YS	VVURPkXWXC_@LA\>]RQYD@MSB^VX\[YSFQ@AFZRUXGQ>NRU PPPEFXE	XCDS]V]N]\U[DX CSL@D ]FAVZuvgdu`|YLW ^L@N j>M MNEB\\BZFR	C[Q BXUNRU PPPEFXEYLW ^L@N >MFkYLAQVWkNk	U_GSMD@V NRU PPPEFXEYLW ^L@N >>>>\WXF^PSE	YLW ^L@Nsx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiuvgdu`|G@F]ZS^@U[FB_S@YGNYELLL>>>>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZYLW ^L@N>BZ^GEBSkk\D^	WU^YMASDXk_GG>]RBZ^GEBSkk\D^FQ@AFZRUXGQ>>>>L[LVAFZC^Ek@	FG@C SM^kXMSMQR>>>C[Q BXU>UFFUMkkgxaskkkkdxas}zkvugq kkkksaufpkzuyqkkkkbqfg}{zkk>>>>UFFUMkMZ[W\L[YU[BZ^GEBSkk\D^\WXF^PSEXCDS]V]N]\U[DX C>>]RL[LVAFZC^Ek@O>]R]Z@SQ@k[D@][ZXSDQk^Y[_N[ 
[]\CNNBEZB[Q\APGNWCUNEM RS^]Q]]ZB@[U>>>FQ@AFZRUXGQ>I>>>L[LVAFZC^Ek@	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ L[LVAFZC^Ek@>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iL[LVAFZC^Ek@HHL[LVAFZC^Ek@			FQ@AFZRUXGQ>RYCD]kCCSNU	RUXGQ>R[FQUW\SB^VX\[YSUGV@QV^ L]NA]GW^O>>>>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiV@QV^ L]NA]GW^W[Z@]ZAQ>]RVLAFYQ]ZV[@kUCV@QV^ L]NA]GW^W[Z@]ZAQ>GP QNZkML	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vtsx{vuxgokkGWRkS\CU__XX EZkiV@QV^ L]NA]GW^WRUXGQ>]RGP QNZkML		RUXGQsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM tRX[W_GP QNZkMLx{wkqlHx{wkzvO>tRWX[GQGP QNZkML>>W[Z@]ZAQ>I>WAFFQZ@	tsx{vuxgokkGWRkBYEVDGkUNk iV@QV^ L]NA]GW^>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGNWCUNEM U_GSMD@V>>]RGP QNZkML		RUXGQO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ tRX[W_GP QNZkMLx{wkaz>>>tRWX[GQGP QNZkML>I>W[Z@]ZAQ>I>@FMO>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@
  WAFFQZ@	^UNF\NZMLZLZkN[XAWAFFQZ@>>>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@M MNEB\\BZFR		RUXGQsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@MFkYLAQVWkNk		RUXGQO>RYCD]kCCSNU	@FAQ>W[Z@]ZAQ>I>>>]Rtsx{vuxgokkGWRk_XXP] C^Mk iV@QV^ L]NA]GW^W[Z@]ZAQ>>>>BMQQ[APNN	SL@D ]FAVZuvgdu`|YLW ^L@N j>XGLGL\QPQSQR]VSQ	WAFFQZ@>>>>WAFFQZ@	E[BD@ER_  MBAZWAFFQZ@RS^]Q]]ZB@[UC[Q BXU>WAFFQZ@	sx{vuxgokkGWRkWBQASY @NZRk iRS^]Q]]ZB@[U WAFFQZ@>]Rsx{vuxgokkGWRkCGC  VMVVk iWAFFQZ@O>[]\CNNBEZB[Q\APGNWCUNEM C[Q BXU>W[Z@]ZAQ>I>>>>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@YLW ^L@N		RUXGQHHsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@U_GSMD@V		RUXGQO>PA@YA[PP	sx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@NWCUNEM>>>]_CGFN]RV^B	PA@YA[PP		RUXGQsx{vuxgokkGWRkQDZV_kiWAFFQZ@PA@YA[PPWAFFQZ@>>]Rsx{vuxgokkGWRkUAU[DUV]kWki]_CGFN]RV^BRS^]Q]]ZB@[U			RUXGQsx{vuxgokkGWRkUAU[DUV]kWki]_CGFN]RV^BU_GSMD@V			RUXGQsx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[UBMQQ[APNNNWCUNEM]_CGFN]RV^BO>[]\CNNBEZB[Q\APGC[Q BXU NWCUNEM>W[Z@]ZAQ>I>>]F@]EMG G	sx{vuxgokkGWRkWBQASY @NZRk iNWCUNEMhZWAFFQZ@>]Rsx{vuxgokkGWRkCGC  VMVVk i]F@]EMG GWAFFQZ@	]F@]EMG G>]F@]EMG G	sx{vuxgokkGWRkWBQASY @NZRk iXSDQk^Y[_N[ WAFFQZ@>]Rsx{vuxgokkGWRkCGC  VMVVk i]F@]EMG GWAFFQZ@	]F@]EMG G>AZGQ@]F@]EMG G>]Rsx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@U_GSMD@V		RUXGQO>[]\CNNBEZB[Q\APGNWCUNEMXSDQk^Y[_N[ >W[Z@]ZAQ>I>I>]RRYCD]kCCSNUO>>>>]RWAFFQZ@			XGLGL\QPQSQR]VSQW[Z@]ZAQ>AYZ]RZWU_ADX	tsx{vuxgokkGWRkBYEVDGkUNk iV@QV^ L]NA]GW^>]Rsx{vuxgokkGWRkCGC  VMVVk iAYZ]RZWU_ADXW[Z@]ZAQ>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiAYZ]RZWU_ADX
 AYZ]RZWU_ADX	^UNF\NZMLZLZkN[XAAYZ]RZWU_ADX>]RAYZ]RZWU_ADX		XGLGL\QPQSQR]VSQO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UU_GSMD@V>W[Z@]ZAQ>I>AZGQ@AYZ]RZWU_ADX>]RWGUYPNQENN@V@QV^ L]NA]GW^WAFFQZ@W[Z@]ZAQ>]RMRFkUDFEFUZV@QV^ L]NA]GW^WAFFQZ@W[Z@]ZAQ>]R^EQW_ZP\[\_^S^V@QV^ L]NA]GW^WAFFQZ@]__CZGUREPA@SB^V@QV^ L]NA]GW^>W[Z@]ZAQ>I>]Rsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[  WAFFQZ@O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UYLW ^L@N>>>W[Z@]ZAQ>I>Wkk[G\\^\	RS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@
sx{vuxgokkGWRkUAU[DUV]kWkiWAFFQZ@U_GSMD@V 		RUXGQO>VRYLGSWSE@DN	RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU O>DVZZ^R@QC_ZW	t@[_QZkSQ@kUXXWAFFQZ@>]Rsx{vuxgokkGWRkWBSB\_k iDVZZ^R@QC_ZWO>R[FQUW\DVZZ^R@QC_ZWUG[[F]\LNWGLFC@O>]Rsx{vuxgokkGWRkWBSB\_k i[[F]\LNWGLFC@O>]R[[F]\LNWGLFC@oi			`k{dqzk`usHHPQR]ZQPRS^]Q]]ZB@[U[[F]\LNWGLFC@oi			`k{dqzk`uskc}`|kqw|{VRYLGSWSE@DN	@FAQ>QXGQ]R[[F]\LNWGLFC@oi			`kwx{gqk`usVRYLGSWSE@DN	RUXGQ>>I>>I>I>AZGQ@DVZZ^R@QC_ZW[[F]\LNWGLFC@>>>>IQXGQO>EM]_VBWC]RV	sx{vuxgokkGWRkCEF[E]PAMDkNkiWAFFQZ@NWCUNEM>>>R]XF SGZZ	sx{vuxgokkGWRkCEF[E]PAMDkNkiWAFFQZ@U_GSMD@V >]REM]_VBWC]RV		RUXGQR]XF SGZZ			RUXGQHHEM]_VBWC]RV
R]XF SGZZVRYLGSWSE@DN	@FAQ>AZGQ@EM]_VBWC]RVR]XF SGZZ>I>]RVRYLGSWSE@DNWkk[G\\^\	>AZGQ@VRYLGSWSE@DN>I>>Y_kNNG	sx{vuxgokkGWRkD@WYYENNCMMkkiWAFFQZ@
hZ>MkQRSWYPRX	sx{vuxgokkGWRkR_]RRR^ ESki\WXF^PSE\WXF^PSEksx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiV@QV^ L]NA]GW^jL[LVAFZC^Ek@>LAQNkXPW]	Y_kNNGWkk[G\\^\M MNEB\\BZFRhZMkQRSWYPRXhZMFkYLAQVWkNkhZ>AZGQ@MkQRSWYPRX>AYZ]RZWU_ADX	tsx{vuxgokkGWRkBYEVDGkUNk iV@QV^ L]NA]GW^>>]Rsx{vuxgokkGWRkCGC  VMVVk iAYZ]RZWU_ADXO>AZGQ@XGLGL\QPQSQR]VSQ>W[Z@]ZAQ>I>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiAYZ]RZWU_ADX
AYZ]RZWU_ADX	^UNF\NZMLZLZkN[XAAYZ]RZWU_ADX>]RAYZ]RZWU_ADX		XGLGL\QPQSQR]VSQO>AZGQ@AYZ]RZWU_ADXXGLGL\QPQSQR]VSQ>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ C[Q BXU>W[Z@]ZAQ>>>I>AZGQ@AYZ]RZWU_ADXXGLGL\QPQSQR]VSQ>]RWGUYPNQENN@V@QV^ L]NA]GW^WAFFQZ@W[Z@]ZAQ>]RMRFkUDFEFUZV@QV^ L]NA]GW^WAFFQZ@O>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[UNWCUNEM>W[Z@]ZAQ>I>]R^EQW_ZP\[\_^S^V@QV^ L]NA]GW^WAFFQZ@LAQNkXPW]W[Z@]ZAQ>]__CZGUREPA@SB^V@QV^ L]NA]GW^>>RYCD]kCCSNU	@FAQ>IR]ZUXXMO>]RGP QNZkML		RUXGQO>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtRX[W_GP QNZkMLx{wkaz>tRWX[GQGP QNZkML>I>I>I>FQ@AFZRYCD]kCCSNU>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>FQ@AFZRUXGQ>IWU@W\qLWQD@][Z[GD[EZLNO>FQ@AFZRUXGQ>I>I>RAZW@][Z]k QVCVkCZ^_Zk>O>@FMO>]RPQR]ZQPU_GSMD@VFQ@AFZ>]RV@  NBWM[ML[CR^N]SFX^UDZ^SGFZFQ@AFZ>M YGAF^PE@ZQB	AEZGREWF[>>XDN^VABEUF	SL@D ]FAVZuvgdu`|C[Q BXU  jYLW ^L@N >kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[  >Rk[NLS^]	Z@SSV]@AXS]ZZY>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]LVL O>>>>[]\CNNBEZB[Q\APGU_GSMD@V XSDQk^Y[_N[   >FQ@AFZ>I>]Rsx{vuxgokkGWRkQk[VUA]AQRk iRS^]Q]]ZB@[U FQ@AFZ>>>DQVLCCAW^S_B	UFFUM>M YGAF^PE@ZQBXDN^VABEUF>M YGAF^PE@ZQBRS^]Q]]ZB@[U sx{vuxgokkGWRkWUBDWM@BFELXk iC[Q BXU XDN^VABEUF>>\BBU]]B	PQR]ZQPXSDQk^Y[_N[  cdkw{z`qz`kp}fuvgdu`|XSDQk^Y[_N[ YLW ^L@N>]Rtsx{vuxgokkGWRkY  PFNk i\BBU]]BO>LFPZBUP	[FZWA_XLGNXR\BBU]]B>]Rsx{vuxgokkGWRkWBSB\_k iLFPZBUPO>R[FQUW\LFPZBUPUG[GD[EZLNO>>[C[ALERkB	\BBU]]B[GD[EZLN>]Rtsx{vuxgokkGWRkY  PFNk i[C[ALERkBtsx{vuxgokkGWRk_XXP] C^Mk i[C[ALERkBO>DQVLCCAW^S_Boi	[C[ALERkBXDN^VABEUF>VFQU_>I>I>I>I>R[FQUW\DQVLCCAW^S_BUGMW\SBNV O>]Rtsx{vuxgokkGWRk\]XDEBSkWEkiMW\SBNV tsx{vuxgokkGWRkDNNU_UYWXVVkiMW\SBNV 
O>]WQD]VC\B	NWCUNEM >]Rsx{vuxgokkGWRkQk[VUA]AQRk i]WQD]VC\BO>RS]NACXMQ^Z	ZQC]WQD]VC\B>]RtRS]NACXMQ^Z
[DQZMW\SBNV 			@FAQO>>_MXVRNk^B]	RUXGQ>ZCBUMUURkL	RS]NACXMQ^Z
X[WU@QzUYQkMZ[W\L[YU[kMZ[W\L[YU[NWCUNEM >]RZCBUMUURkL		RUXGQO>CDFDDXX	RS]NACXMQ^Z
G@U@}ZPQLZCBUMUURkL>>]Rsx{vuxgokkGWRkWBSB\_k iCDFDDXX]GGQ@CDFDDXXoYLW ^L@Ni]Z@CDFDDXXoXSDQk^Y[_N[  i	 O>AAYkE^ML M	RS]NACXMQ^Z
SQ@rF[Y}ZPQLZCBUMUURkL>_MXVRNk^B]	sx{vuxgokkGWRkCGC  VMVVk iAAYkE^ML Msx{vuxgokkGWRkk[AFM@ZWUECkiAAYkE^ML M			sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]>AZGQ@AAYkE^ML M>I>AZGQ@CDFDDXX>I>RS]NACXMQ^Z
WX[GQ>]R_MXVRNk^B]W[Z@]ZAQ>>>I>I>>I>PLDRFkX ]D]@Y]	sx{vuxgokkGWRkWLGRkXNMY[kiMW\SBNV >]Rtsx{vuxgokkGWRkY  PFNk iPLDRFkX ]D]@Y]GEWVN@XUE@ P\\ZPLDRFkX ]D]@Y] @FAQ>>>]WQD]VC\B	C[Q BXU >NRFPGD FULk	YZM]DQZ RCCYZAPLDRFkX ]D]@Y]U_GSMD@V>]RNRFPGD FULk			RUXGQW[Z@]ZAQ>>@[k_RZ@LP	ZQC]WQD]VC\B>]Rt@[k_RZ@LP
[DQZNRFPGD FULk]WQD]VC\Bwfqu`qH]WQD]VC\B{bqfcf}`q			@FAQO>@[k_RZ@LP
UPPrF[Yg@F]ZSkMZ[W\L[YU[kMZ[W\L[YU[NWCUNEMRk[NLS^]>@[k_RZ@LP
WX[GQ>^QGALDUWM	ZQC]WQD]VC\B>>]Rt^QGALDUWM
[DQZNRFPGD FULk			@FAQO>^QGALDUWM
WX[GQ>]R]]EN_BYRS]UBkNRFPGD FULkMW\SBNV HH\BY\PG_QP]VFSU[G_GNRFPGD FULkMW\SBNV UC[WM Z NRFPGD FULkO>M^EGF^k]GM C[ZM MW\SBNV P[SC\_^CNZQR^SR@>SUB\XXALLBWR W\F XMW\SBNV  >IQXGQO>UC[WM Z NRFPGD FULk>>>I>IQXGQO>UC[WM Z NRFPGD FULk>I>IQXGQO>UC[WM Z NRFPGD FULk>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZUWFLLY[ELA]BBSC>O>@FMO>>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UHHsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUFQ@AFZ>>>]RPQR]ZQPXSDQk^Y[_N[ FQ@AFZ>FANXG\GF[@	NWCUNEM >]RCDkZQL@kGW\QPAXQPFANXG\GF[@O>CDkGW\QPAXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNkiU_GSMD@VFANXG\GF[@>>I>]RCDkZQL@kGW\QPAXQPXSDQk^Y[_N[ O>CDkGW\QPAXQkQBQZ@sx{vuxgokkGWRkNWYM^SkLZ[BNki NWCUNEMRS^]Q]]ZB@[U>>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZYBEG\CMLG>O>>@FMO>]RPQR]ZQPYLW ^L@NFQ@AFZ>\AGCX_QQD	SL@D ]FAVZuvgdu`|S>\QXBB@Z	UFFUM>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM\QXBB@Zoi	GM_EAV^VFW>\QXBB@Zoi	uvgdu`|C[Q BXU >]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ \QXBB@Zoi	AEZGREWF[>R[FQUW\\QXBB@ZUGZVQCF]O>FXM@Zk]QNDFR	ZVQCF]YLW ^L@N\AGCX_QQD>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiFXM@Zk]QNDFR]Z@tsx{vuxgokkGWRkUMX_NCYCkiFXM@Zk]QNDFR
sx{vuxgokkGWRkNWYM^SkLZ[BNki FQ@AFZ>I>R[FQUW\\QXBB@ZUGZVQCF]O>@[FRDGCFN@W	ZVQCF]RS^]Q]]ZB@[U\AGCX_QQD>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@[FRDGCFN@WO>VZ@AUCVNLYX	]Z@tsx{vuxgokkGWRkUMX_NCYCki@[FRDGCFN@W>]RVZ@AUCVNLYX
sx{vuxgokkGWRkNWYM^SkLZ[BNki VZ@AUCVNLYX	sx{vuxgokkGWRkNWYM^SkLZ[BNkiW[Z@]ZAQ>>UC[WM Z @[FRDGCFN@W>I>^PWkX]EUXNG@]	ZVQCF]U_GSMD@V\AGCX_QQDYLW ^L@N>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki^PWkX]EUXNG@]]Z@tsx{vuxgokkGWRkDNNU_UYWXVVki^PWkX]EUXNG@]
 O>>>>ZZXRG@W_^R	ZVQCF]NWCUNEM\AGCX_QQD>>GDPY UYQL	tsx{vuxgokkGWRk@Y@R NPPDCC@kiZZXRG@W_^Rsx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iZZXRG@W_^R>]RGDPY UYQL		sx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  tYPkR]XQ^PWkX]EUXNG@]			GDPY UYQLO>>>t]ZWXAPQ^PWkX]EUXNG@]>>>FQ@AFZ>I>]RGDPY UYQL		O>>UC[WM Z ^PWkX]EUXNG@]>I>AZGQ@ZZXRG@W_^RGDPY UYQL>I>I>AZGQ@@[FRDGCFN@WVZ@AUCVNLYX>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMtPQXQ@Qk@FUZG]QZ@YLW ^L@N>S_\_RA^UkAL\[^Y>IWU@W\`\F[CUVXQ[GD[EZLNO>>>>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>I>I>>>RAZW@][Z[QM [@D^ZN@@>O>@FMO>]RPQR]ZQPNWCUNEMFQ@AFZ>>>>@WRYSCWMRD]^PLZAXX>kMZ[W\L[YU[	sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZU_GSMD@V>@WXL\XNC@D	R^N]SFX^UDZ^SGFZ>>Rk[NLS^]	>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@WXL\XNC@Dtsx{vuxgokkGWRkDNNU_UYWXVVki@WXL\XNC@D
 O>W@kWWXMSZY_P	SFFMRN]XGWQN@WXL\XNC@D>]Rsx{vuxgokkGWRkCGC  VMVVk iW@kWWXMSZY_Psx{vuxgokkGWRkD@WYYENNCMMkkiW@kWWXMSZY_P
 M[YQk NNVYMFB\W@kWWXMSZY_PRk[NLS^]	W@kWWXMSZY_P>>AZGQ@W@kWWXMSZY_P>I>]RRk[NLS^]			O>>SASXkDk  _	SL@D ]FAVZuvgdu`|RS^]Q]]ZB@[U LL>BZ^GEBSkk\D^	sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUtSQ@k[D@][ZSASXkDk  _>]RBZ^GEBSkk\D^HHsx{vuxgokkGWRkD@WYYENNCMMkkiBZ^GEBSkk\D^   FQ@AFZ>>>>Rk[NLS^]	QSk@_kALNAZZsx{vuxgokkGWRkWBDQ[VVAZE\kiBZ^GEBSkk\D^>>>>]RRk[NLS^]HHsx{vuxgokkGWRkD@WYYENNCMMkkiRk[NLS^]  FQ@AFZ>]RM[YQk NNVYMFB\Rk[NLS^]O>>>>[]\CNNBEZB[Q\APGXSDQk^Y[_N[ XSDQk^Y[_N[  >FQ@AFZ>I>I>M YGAF^PE@ZQB	AEZGREWF[>SE]VQS E_PR	M YGAF^PE@ZQBU_GSMD@VkMZ[W\L[YU[>>>Q kVkVB[k LP	SE]VQS E_PRkMZ[W\L[YU[XSDQk^Y[_N[ >]Rtsx{vuxgokkGWRkY  PFNk iSE]VQS E_PRGEWVN@XUE@ P\\ZSE]VQS E_PRLLWU@FAQ>__U_ VFMCVAPN\	tsx{vuxgokkGWRk@Y@R NPPDCC@kiQ kVkVB[k LPSFFMRN]XGWQNQ kVkVB[k LP>@ kRFS@	__U_ VFMCVAPN\			ZAXX>]Rsx{vuxgokkGWRkCGC  VMVVk i__U_ VFMCVAPN\__U_ VFMCVAPN\		sx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[  sx{vuxgokkGWRkQDZV_ki__U_ VFMCVAPN\ ^QQC[^RULR BQFG][ZkW[YDUFQ^QQC[^RULR oiXCDS]V]N]\U[DX C
@ kRFS@	@FAQ>AZGQ@^QQC[^RULR >]R@ kRFS@sx{vuxgokkGWRkCGC  VMVVk i__U_ VFMCVAPN\HH__U_ VFMCVAPN\			HHsx{vuxgokkGWRkk[AFM@ZWUECki__U_ VFMCVAPN\		sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]O>>]R^EQW_ZP\[\_^S^Q kVkVB[k LPMV\Yk_]LXPMRk[NLS^]O>SUB\XXALLBWR W\F XQ kVkVB[k LP>CUB_YSQVGGNP[_BQ kVkVB[k LP>RkV [kV DU^_Q kVkVB[k LP>I>I>AZGQ@__U_ VFMCVAPN\@ kRFS@>CWLVVG\WZFFAPkMZ[W\L[YU[kMZ[W\L[YU[YLW ^L@N>ULLQ]SRVEM	VZ[[SF]P]DGWUAZ>]Rtsx{vuxgokkGWRkY  PFNk iULLQ]SRVEMtsx{vuxgokkGWRk_XXP] C^Mk iULLQ]SRVEMHHtsx{vuxgokkGWRkY  PFNk iULLQ]SRVEMGEWVN@XUE@ P\\ZULLQ]SRVEMLPRLQ@FAQO>LL AF VSB@Y@AR	ULLQ]SRVEMkMZ[W\L[YU[NWCUNEM>C^ZRSSEGV^	tsx{vuxgokkGWRk@Y@R NPPDCC@kiLL AF VSB@Y@ARSFFMRN]XGWQNLL AF VSB@Y@AR>@AGG[ Q V\^N^	C^ZRSSEGV^			ZAXX>]Rsx{vuxgokkGWRkCGC  VMVVk iC^ZRSSEGV^C^ZRSSEGV^		sx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXU sx{vuxgokkGWRkQDZV_kiC^ZRSSEGV^@ARNZCYPSEBQFG][ZkW[YDUFQ@ARNZCYPSEoiXCDS]V]N]\U[DX C
@AGG[ Q V\^N^	@FAQ>>>AZGQ@@ARNZCYPSE>>]R@AGG[ Q V\^N^sx{vuxgokkGWRkCGC  VMVVk iC^ZRSSEGV^HHC^ZRSSEGV^			HHsx{vuxgokkGWRkk[AFM@ZWUECkiC^ZRSSEGV^		sx{vuxgokkGWRkk[AFM@ZWUECkiRk[NLS^]O>]R^EQW_ZP\[\_^S^LL AF VSB@Y@ARMV\Yk_]LXPMRk[NLS^]O>SUB\XXALLBWR W\F XLL AF VSB@Y@AR>CUB_YSQVGGNP[_BLL AF VSB@Y@AR>RkV [kV DU^_LL AF VSB@Y@AR>I>IQXGQ]R@AGG[ Q V\^N^O>SEBRLLGE	tsx{vuxgokkGWRkUMX_NCYCkiLL AF VSB@Y@AR>]RSEBRLLGEHHSEBRLLGE 		^@U[FB_S@YGNYELCUB_YSQVGGNP[_BLL AF VSB@Y@AR>AZGQ@SEBRLLGE>>>I>>AZGQ@C^ZRSSEGV^@AGG[ Q V\^N^>I>>>>SLXEXL ZZA^YRk[NLS^]>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>>I>I>RAZW@][ZRRLND[EMMSAAkW>O>>]R]GGQ@ksq`oDiHHsx{vuxgokkGWRkCGC  VMVVk iksq`oDiFQ@AFZ>>>>WCFRRG EGLRM	ksq`oDi>]RWCFRRG EGLRM			NBUZPGUYBEXCXSDQk^Y[_N[ O>sx{vuxgoRS^]Q]]ZB@[Ui	@FAQ>>>>@FMO>WB@NYES@NW	GM_EAV^VFWSL@D ]FAVZuvgdu`|YLW ^L@NLLU_GSMD@V>_Y [ECRAYRC	tsx{vuxgokkGWRk@Y@R NPPDCC@kiWB@NYES@NW]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiWB@NYES@NW>]R_Y [ECRAYRC
LLVR_Y [ECRAYRC	L WVLV RO>]ZWXAPQWB@NYES@NW>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>IWU@W\qLWQD@][Z[GD[EZLNO>I>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
t[VkQZPkWXQUZO>>>>I>\QUPQFC[Q BXU>>QL]@>I>]RWCFRRG EGLRM		NBUZPGUYBEXCC[Q BXUFQ@AFZ>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ sx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>tADPU@Qk[D@][ZNWCUNEM ]Z@tSQ@k[D@][ZRS^]Q]]ZB@[U YLW ^L@N>>>>tADPU@Qk[D@][ZXSDQk^Y[_N[  sx{vuxgokkGWRkNWYM^SkLZ[BNkiXSDQk^Y[_N[ >I>>>L@GMFS\SR@CU@Q	kP^D_FS\YY WNWCUNEM>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@Q
 jsx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ L@GMFS\SR@CU@Qsx{vuxgokkGWRkUQ Y]ZXWDkiNWCUNEML@GMFS\SR@CU@QO>@RB_ QkCG	tsx{vuxgokkGWRkWBDQ[VVAZE\kiL@GMFS\SR@CU@Q@FAQ>]R@RB_ QkCG		RUXGQsx{vuxgokkGWRkD@WYYENNCMMkki@RB_ QkCG
L@GMFS\SR@CU@Q	@RB_ QkCG>I>>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@Q L@GMFS\SR@CU@Q	_\F]_^UQ_B^N>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiL@GMFS\SR@CU@QO>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
t[VkQZPkWXQUZO>>>I>\QUPQFRS^]Q]]ZB@[U>\QUPQFXSDQk^Y[_N[ >\QUPQFC[Q BXU>QL]@>I>VCAWL]ARV N	kP^D_FS\YY WXSDQk^Y[_N[ >SYkWMCEZ	sx{vuxgokkGWRkk[AFM@ZWUECkiVCAWL]ARV NL@GMFS\SR@CU@Q>]R]GGQ@kgqfbqfoRS^]Q]]ZB@[Uisx{vuxgokkGWRk\G[ML]GWkikgqfbqfoXSDQk^Y[_N[ i			SYkWMCEZO>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
t[VkQZPkWXQUZO>I>>>\QUPQFRS^]Q]]ZB@[U>\QUPQFNWCUNEMSYkWMCEZ>>>QL]@>I>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
t[VkQZPkWXQUZO>I>\QUPQFU_GSMD@V>\QUPQFYLW ^L@N>\QUPQFU_GSMD@V >\QUPQFNWCUNEMSYkWMCEZ>QW\[VCAWL]ARV NL@GMFS\SR@CU@Q>QL]@>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N[GD[EZLN>>>>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>I>>I>>>>RRLND[EMMSAAkW>RAZW@][ZUUNWUZB]]W>O>]R]GGQ@ksq`oXSDQk^Y[_N[ iFQ@AFZ>@FMO>>>D_QBkVVWAQPAR	ksq`oXSDQk^Y[_N[ i>>>>]Rsx{vuxgokkGWRkCGC  VMVVk iD_QBkVVWAQPARHHD_QBkVVWAQPAR			FQ@AFZ>D_QBkVVWAQPAR	sx{vuxgokkGWRkX@FXkiD_QBkVVWAQPAR>XDU]PB\	UFFUM>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM XDU]PB\oi	G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxk|{g`>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>[PPFQGB@	G@F]ZStSQ@k[D@][ZNWCUNEM>]R[PPFQGB@		XDU]PB\oi	G@F]ZSsx{vuxgokkGWRkk@\\]WGVki[PPFQGB@d|dkafxk|{g`>>I>]R]GGQ@kgqfbqfoNWCUNEMiXDU]PB\oi	G@F]ZSkgqfbqfoC[Q BXUi>XDU]PB\oi	]]Ak[ZG\^^RAP]UMA>BSDGBS_YADM	RUXGQ>>>R[FQUW\sx{vuxgokkGWRk_SM[G_FkLFk iXDU]PB\UGN_QFQSGPkGSL]O>>]Rsx{vuxgokkGWRkCGC  VMVVk iN_QFQSGPkGSL]HHN_QFQSGPkGSL]			W[Z@]ZAQ>]Rsx{vuxgokkGWRkUAU[DUV]kWkiN_QFQSGPkGSL]		RUXGQN_QFQSGPkGSL]	sx{vuxgokkGWRkWBQASY @NZRk iYLW ^L@NN_QFQSGPkGSL]>>>]RSL@D ]FAVZsx{vuxgokkGWRkX@FXkiN_QFQSGPkGSL]NWCUNEMLL			D_QBkVVWAQPARO>BSDGBS_YADM	@FAQ>VFQU_>I>I>>]RBSDGBS_YADMFQ@AFZ>>>WRED_F EE@A]W	sx{vuxgokkGWRkD]LA]Q^VkiYLW ^L@N>E_ GUFR [	QSk@_kALNAZZF[GDUDUYA_[_^kQAWRED_F EE@A]W>C\]XQsx{vuxgokkGWRk\^DUBFDPYUDk i
t[VkQZPkWXQUZO>I>\QUPQFYLW ^L@N>\QUPQFXSDQk^Y[_N[ >QW\[E_ GUFR [			WRED_F EE@A]WU_GSMD@Vsx{vuxgokkGWRkk[AFM@ZWUECkiWRED_F EE@A]WRS^]Q]]ZB@[U>QL]@>>>>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>>>>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>I>I>UUNWUZB]]W>RAZW@][Z@WUEVQEG\SMLR ]MR>O>BSDGBS_YADM	@FAQ>AZPG@LLQk\	RAZW@][ZU_ NQDLS[G[SAGQBSDGBS_YADMO>@FMO>sx{vuxgokkGWRk_[B\CCNMkiU_ NQDLS[G[S>IWU@W\`\F[CUVXQ[GD[EZLNO>>BSDGBS_YADM	RUXGQ>>IWU@W\qLWQD@][Z[GD[EZLNO>BSDGBS_YADM	RUXGQ>I>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UAZPG@LLQk\U_GSMD@V>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ AZPG@LLQk\RS^]Q]]ZB@[U>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UAZPG@LLQk\C[Q BXU>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ AZPG@LLQk\YLW ^L@N>QXGQ]Rsx{vuxgokkGWRkQk[VUA]AQRk iRS^]Q]]ZB@[Usx{vuxgokkGWRkUU\RUWEQkiU_GSMD@VYLW ^L@NAZPG@LLQk\UFFUMYLW ^L@NYLW ^L@N>]Rsx{vuxgokkGWRkQk[VUA]AQRk iXSDQk^Y[_N[  sx{vuxgokkGWRkUU\RUWEQkiC[Q BXU XSDQk^Y[_N[ AZPG@LLQk\UFFUMXSDQk^Y[_N[  YLW ^L@N>]Rsx{vuxgokkGWRkQk[VUA]AQRk iYLW ^L@Nsx{vuxgokkGWRkUU\RUWEQkiYLW ^L@NC[Q BXUAZPG@LLQk\UFFUMU_GSMD@VYLW ^L@N>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@VAZPG@LLQk\RS^]Q]]ZB@[U>>>QXGQ]R]GGQ@sx{vuxgoRS^]Q]]ZB@[Uisx{vuxgokkGWRk@L\SQY@ZAkisx{vuxgoXSDQk^Y[_N[ isx{vuxgokkGWRkUU\RUWEQkisx{vuxgoYLW ^L@NiNWCUNEMAZPG@LLQk\RAZW@][ZO>sx{vuxgoXSDQk^Y[_N[ i
PQXQ@QwUW\Q@FAQ>>>>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UAZPG@LLQk\XSDQk^Y[_N[ >]Rsx{vuxgokkGWRkQk[VUA]AQRk iRS^]Q]]ZB@[U sx{vuxgokkGWRkUU\RUWEQkiYLW ^L@N YLW ^L@NAZPG@LLQk\UFFUMRS^]Q]]ZB@[UXSDQk^Y[_N[ >>>[]\CNNBEZB[Q\APGU_GSMD@V  C[Q BXU>FQ@AFZBSDGBS_YADM>I>RAZW@][ZEkDU[RRLUFDRZV>>>>O>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ ]GkUPY]ZFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UCDkP[]ZSkU^ULFQ@AFZ@FAQ>]RPQR]ZQPNWCUNEMfqg`kfqeaqg`FQ@AFZ@FAQ>]RPQR]ZQPC[Q BXUlyxfdwkfqeaqg`FQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N]GkRQQPFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N]GkF[V[@GFQ@AFZ@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU]GkG]@QYUDGFQ@AFZ@FAQ>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N ]GkWAG@[Y]NQkDFQB]QCFQ@AFZ@FAQ>]R]GGQ@ksq`oNWCUNEMiHH]GGQ@ksq`oC[Q BXUiHH]GGQ@ksq`oC[Q BXUiFQ@AFZ@FAQ>>FQ@AFZRUXGQ>I>>RAZW@][ZX_[ERV WBk>O>>>\F@@WWNN	]GGQ@sx{vuxgoYLW ^L@Nisx{vuxgokkGWRkCGC  VMVVk isx{vuxgoYLW ^L@Nisx{vuxgokkGWRk\G[ML]GWkisx{vuxgoC[Q BXUi>]R\F@@WWNN			FQ@AFZ>\F@@WWNN	sx{vuxgokkGWRkR_]RRR^ ESkiYLW ^L@NRS^]Q]]ZB@[U\F@@WWNN>SP\AME@kMk_[	sx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxk|{g`>S[ ^PZUYF\Q U	SL@D ]FAVZsx{vuxgokkGWRkX@FXkiSP\AME@kMk_[>[VM VY@M]AQ	sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECki\F@@WWNN>FQ@AFZhZGWF]D@PU@UGW	hS[ ^PZUYF\Q U[VM VY@M]AQh
hZ\F@@WWNNhZGWF]D@
hZGWS[ ^PZUYF\Q U[VM VY@M]AQ
hZ>>>I>RAZW@][ZG][CPW_]M [N_SVCNWP>O>>@FMO>>>]REkDU[RRLUFDRZVFQ@AFZ>FZDNZGCZGB	X_[ERV WBk>]RFZDNZGCZGB			FQ@AFZ>>>QW\[FZDNZGCZGB>sx{vuxgoXSDQk^Y[_N[  i	@FAQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@Vsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ QYD@Msx{vuxgoU_GSMD@ViO>sx{vuxgoXSDQk^Y[_N[ i	@FAQ>C[Fk]VC\YS	]Z@tSQ@k[D@][ZU_GSMD@V >]Rsx{vuxgokkGWRkNWYM^SkLZ[BNkiC[Fk]VC\YS
tADPU@Qk[D@][ZU_GSMD@Vsx{vuxgokkGWRkNWYM^SkLZ[BNkiNWCUNEM>AZGQ@C[Fk]VC\YS>>>>I>IWU@W\`\F[CUVXQ[GD[EZLNO>>>[]\CNNBEZB[Q\APGNWCUNEM[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZCDXXV\LA GN]YUVNM\FY_LU@@U]DCQYF@ UQDN	>O>]Rsx{vuxgokkGWRkCGC  VMVVk iNM\FY_LU@@HHNM\FY_LU@@			FQ@AFZNM\FY_LU@@>]RPQR]ZQPC[Q BXUU]DCQYF@ UQDNd|dk{a`da`k|uzpxqfkr}zuxFQ@AFZNM\FY_LU@@>]RQYD@Msx{vuxgoYLW ^L@NiFQ@AFZNM\FY_LU@@>]RQYD@Msx{vuxgoXSDQk^Y[_N[  iFQ@AFZNM\FY_LU@@>]Rsx{vuxgokkGWRkD@WYYENNCMMkkiNM\FY_LU@@
    FQ@AFZNM\FY_LU@@>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU O>>>>R[FQUW\UFFUMt\QUPQFGkX]G@UG@]ACPYRkVG][O>]RG@F]D[G@]ACPYRkVG][NWCUNEM			G@F]D[G@]ACPYRkVG][XSDQk^Y[_N[ 		RUXGQFQ@AFZNM\FY_LU@@>]RG@F]D[G@]ACPYRkVG][U_GSMD@V			G@F]D[G@]ACPYRkVG][RS^]Q]]ZB@[U 			RUXGQG@F]D[G@]ACPYRkVG][XSDQk^Y[_N[  			RUXGQFQ@AFZNM\FY_LU@@>I>AZGQ@@]ACPYRkVG][>I>FZDNZGCZGB	X_[ERV WBk>]RFZDNZGCZGB			FQ@AFZNM\FY_LU@@>]RG@F]D[GNM\FY_LU@@U_GSMD@V 			RUXGQG@F]D[GNM\FY_LU@@XSDQk^Y[_N[  			RUXGQFQ@AFZNM\FY_LU@@>sx{vuxgoXSDQk^Y[_N[   i	@FAQ>sx{vuxgoRS^]Q]]ZB@[U i	@FAQ>C\\\ZNQ\B[W]	G@F]D[GNM\FY_LU@@XSDQk^Y[_N[  >]RC\\\ZNQ\B[W]		RUXGQO>FQ@AFZsx{vuxgokkGWRkQDZV_kiNM\FY_LU@@C\\\ZNQ\B[W]FZDNZGCZGBsx{vuxgokkGWRkQDZV_kiNM\FY_LU@@C\\\ZNQ\B[W]>I>FQ@AFZNM\FY_LU@@FZDNZGCZGB>I>RAZW@][ZZDWG N]W EAPEN\MDGQ>O>@FMO>]REkDU[RRLUFDRZVFQ@AFZ>]RQYD@Msx{vuxgoYLW ^L@NiFQ@AFZ>]RQYD@Msx{vuxgoNWCUNEM iFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U FQ@AFZ>\F@@WWNN	]GGQ@sx{vuxgoXSDQk^Y[_N[ isx{vuxgokkGWRkCGC  VMVVk isx{vuxgoXSDQk^Y[_N[ isx{vuxgokkGWRk\G[ML]GWkisx{vuxgoRS^]Q]]ZB@[Ui>]R\F@@WWNN			FQ@AFZ>]CAk@FD	]GGQ@kgqfbqfoC[Q BXU iG@F]ZSkgqfbqfoC[Q BXU i>>>]R]CAk@FD		sx{vuxgokkGWRkUQ Y]ZXWDkiRS^]Q]]ZB@[U]CAk@FDFQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXU O>R[FQUW\UFFUMt\QUPQFGkX]G@UG@]ACPYRkVG][O>]RG@F]D[G@]ACPYRkVG][XSDQk^Y[_N[ 			G@F]D[G@]ACPYRkVG][U_GSMD@V		RUXGQFQ@AFZ>>>]RG@F]D[G@]ACPYRkVG][C[Q BXU			G@F]D[G@]ACPYRkVG][YLW ^L@N			RUXGQG@F]D[G@]ACPYRkVG][NWCUNEM 			RUXGQFQ@AFZ>>>]RG@F]D[G@]ACPYRkVG][RS^]Q]]ZB@[U			FQ@AFZ>I>AZGQ@@]ACPYRkVG][>I>sx{vuxgoU_GSMD@V i	@FAQ>>>>tsx{vuxgokkGWRkNRBUCM@k iXSDQk^Y[_N[ >IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGU_GSMD@V [GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>RAZW@][ZGk]EYkYQ\CE LR]@S>O>@FMO>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMFQ@AFZ>]R]GkUPY]Z]GGQ@sx{vuxgoYLW ^L@NiHHsx{vuxgoYLW ^L@Ni		NWCUNEM FQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[  ]GkGGXFQ@AFZ>BYB]RZW ]	kP^D_FS\YY WYLW ^L@N  >S[ ^PZUYF\Q U	SL@D ]FAVZuvgdu`|U_GSMD@V >YMN[U\CB@ RCGX	C[Q BXU>]RBYB]RZW ]			O>>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEM]Z@tSQ@k[D@][ZXSDQk^Y[_N[ O>tADPU@Qk[D@][ZNWCUNEMC[Q BXU>SGVFEFV	G@F]ZStSQ@k[D@][ZNWCUNEM>QW\[hZNWCUNEMS[ ^PZUYF\Q U
>NWCUNEM>RS^]Q]]ZB@[UYMN[U\CB@ RCGXXSDQk^Y[_N[ U_GSMD@V >XSDQk^Y[_N[ sx{vuxgokkGWRkPDZXFZEVS\SkiSGVFEFV>YLW ^L@NYMN[U\CB@ RCGXC[Q BXUYLW ^L@N>NWCUNEMYMN[U\CB@ RCGXRS^]Q]]ZB@[URS^]Q]]ZB@[UYMN[U\CB@ RCGXYLW ^L@NXSDQk^Y[_N[ YMN[U\CB@ RCGXYLW ^L@N NWCUNEMYMN[U\CB@ RCGXYLW ^L@NNWCUNEM>RS^]Q]]ZB@[UYMN[U\CB@ RCGXC[Q BXUNWCUNEMYMN[U\CB@ RCGXC[Q BXUNWCUNEM>YLW ^L@NhZ>AZGQ@SGVFEFV>I>FQ@AFZ>>>>I>BYB]RZW ]	sx{vuxgokkGWRkR_]RRR^ ESkiC[Q BXU U_GSMD@V  BYB]RZW ]>]Rsx{vuxgokkGWRkUAU[DUV]kWkiBYB]RZW ]NWCUNEM  		BYB]RZW ]	C[Q BXU  sx{vuxgokkGWRkBL_FA]]]WPkiBYB]RZW ]>CXU@CUAQB]RC	>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@N O>BMNVG]EY@V[M\	G@F]ZSsx{vuxgokkGWRkk@\\]WGVki\[YQkAFXd|dkafxkdu`|>]RBMNVG]EY@V[M\		BMNVG]EY@V[M\		CXU@CUAQB]RC	sx{vuxgokkGWRkDMF\VYFZMkiBMNVG]EY@V[M\>I>]Rsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>>tADPU@Qk[D@][ZU_GSMD@VYLW ^L@N >tADPU@Qk[D@][ZNWCUNEMBYB]RZW ]RS^]Q]]ZB@[U >I>>>B@DRVUGMV	NWCUNEMS[ ^PZUYF\Q U
>U_GSMD@V>XSDQk^Y[_N[ YMN[U\CB@ RCGXRS^]Q]]ZB@[UU_GSMD@V>NWCUNEM>U_GSMD@VYMN[U\CB@ RCGXXSDQk^Y[_N[ YLW ^L@Nsx{vuxgokkGWRkPDZXFZEVS\SkiBYB]RZW ]>C[Q BXUYMN[U\CB@ RCGXYLW ^L@NXSDQk^Y[_N[ YMN[U\CB@ RCGXXSDQk^Y[_N[ NWCUNEMYMN[U\CB@ RCGXU_GSMD@VRS^]Q]]ZB@[UYMN[U\CB@ RCGXYLW ^L@NC[Q BXUsx{vuxgokkGWRkPDZXFZEVS\SkiBYB]RZW ]C[Q BXU >U_GSMD@VYMN[U\CB@ RCGXXSDQk^Y[_N[ U_GSMD@Vsx{vuxgokkGWRkPDZXFZEVS\SkiBYB]RZW ]U_GSMD@Vsx{vuxgokkGWRkPDZXFZEVS\SkiCXU@CUAQB]RCC[Q BXUYMN[U\CB@ RCGXRS^]Q]]ZB@[UC[Q BXU>U_GSMD@VYMN[U\CB@ RCGXYLW ^L@NNWCUNEM>>>C[Q BXUYMN[U\CB@ RCGXC[Q BXUU_GSMD@VYMN[U\CB@ RCGXYLW ^L@NRS^]Q]]ZB@[U >>RS^]Q]]ZB@[UYMN[U\CB@ RCGXXSDQk^Y[_N[ XSDQk^Y[_N[ >U_GSMD@V>C[Q BXUYMN[U\CB@ RCGXNWCUNEMYLW ^L@N>>>>RS^]Q]]ZB@[UYMN[U\CB@ RCGXYLW ^L@NYLW ^L@NYMN[U\CB@ RCGXYLW ^L@NU_GSMD@V>C[Q BXU>QW\[hZB@DRVUGMVhZ>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGYLW ^L@N [GD[EZLN>>IWU@W\qLWQD@][Z[GD[EZLNO>[]\CNNBEZB[Q\APGNWCUNEM [GD[EZLN>I>I>>]RYLkS@ ^CN GkMO>FQ@AFZ>I>S_QRWZAY Q>EVXGYZk C[	tsx{vuxgokkGWRkUMX_NCYCkiR^N]SFX^UDZ^SGFZ>>]REVXGYZk C[HHEVXGYZk C[  		^@U[FB_S@YGNYELO>GM^EE CRDR	sx{vuxgokkGWRkNWYM^SkLZ[BNki>>>>M^EGF^k]GM C[ZM R^N]SFX^UDZ^SGFZGM^EE CRDRGM^EE CRDR ^@U[FB_S@YGNYEL>>>AZGQ@GM^EE CRDR>I>>AZGQ@EVXGYZk C[>MLFWQGAWCY	sx{vuxgokkGWRkWLGRkXNMY[kikkr}xqkkYLW ^L@Nsx{vuxgokkGWRkQANE SG_kXV\kikkr}xqkkXSDQk^Y[_N[ >[VWLM@ZLYB@	tsx{vuxgokkGWRk@Y@R NPPDCC@kiMLFWQGAWCY]Z@tsx{vuxgokkGWRkUMX_NCYCkiMLFWQGAWCY>>VG][GQXGXM	[VWLM@ZLYB@
sx{vuxgokkGWRkNWYM^SkLZ[BNkiLL[VWLM@ZLYB@	sx{vuxgokkGWRkNWYM^SkLZ[BNki>]RVG][GQXGXMtsx{vuxgokkGWRkABFEYZ\]WX]@kiMLFWQGAWCY>AZGQ@MLFWQGAWCY[VWLM@ZLYB@>]RVG][GQXGXM@FMO>RWYCEAVM@	kkr}xqkk>>>GSPSAXWSRN]L	>XVVUBR\AM	tsx{vuxgokkGWRkBYEVDGkUNk iRWYCEAVM@RUXGQZAXX >]Rsx{vuxgokkGWRkCGC  VMVVk iXVVUBR\AMsx{vuxgokkGWRkUQ Y]ZXWDkiYLW ^L@N XVVUBR\AMN@SWYEBNkGSPSAXWSRN]L	N@SWYEBNkoi>>]RGSPSAXWSRN]L		PQR]ZQPYLW ^L@N O>@\LUL]DNQMCX_	UFFUM>>VZLZ@WAFU]FY	PQR]ZQPNWCUNEMcdyakdxas}zkp}fcdkw{z`qz`kp}fYLW ^L@N >AGR\SZYFGE	PQR]ZQPC[Q BXUcdkdxas}zkp}fcdkw{z`qz`kp}fU_GSMD@V>>>>SFYD]BUWQAB	RUXGQ>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>Q XQCPRkNMkLE	tsx{vuxgokkGWRkY  PFNk iVZLZ@WAFU]FYtsx{vuxgokkGWRkV^E_YEEGLMVkiVZLZ@WAFU]FYC[Q BXURUXGQ>_ SZ MXPYRY	tsx{vuxgokkGWRkV^E_YEEGLMVkiAGR\SZYFGEXSDQk^Y[_N[ >]Rsx{vuxgokkGWRkWBSB\_k iQ XQCPRkNMkLEHHsx{vuxgokkGWRkWBSB\_k i_ SZ MXPYRYO>SFYD]BUWQAB	@FAQ>R[FQUW\UFFUMQ XQCPRkNMkLEUGNQUVZYQQANR@\LUL]DNQMCX_oi	NQUVZYQQANR>>>>R[FQUW\UFFUM_ SZ MXPYRYUGNQUVZYQQANR@\LUL]DNQMCX_oi	NQUVZYQQANR>I>AZGQ@Q XQCPRkNMkLE_ SZ MXPYRY>I>]RSFYD]BUWQABO>VBYSSP^RkQ	tsx{vuxgokkGWRkY  PFNk iVZLZ@WAFU]FY[FZWA_XLGNXRVZLZ@WAFU]FY RUXGQ>>>]Rsx{vuxgokkGWRkWBSB\_k iVBYSSP^RkQR[FQUW\VBYSSP^RkQUGUNVSWF\VCSEO>]Rsx{vuxgokkGWRkQDZV_kiUNVSWF\VCSE			RS^]Q]]ZB@[U@\LUL]DNQMCX_oi	VZLZ@WAFU]FYUNVSWF\VCSE>>>>I>>>VBYSSP^RkQ	tsx{vuxgokkGWRkY  PFNk iAGR\SZYFGE[FZWA_XLGNXRAGR\SZYFGELWLWRUXGQ>]Rsx{vuxgokkGWRkWBSB\_k iVBYSSP^RkQR[FQUW\VBYSSP^RkQUGUNVSWF\VCSEO>>>\R\FEX^RNM[_	AGR\SZYFGEUNVSWF\VCSE>>]Rtsx{vuxgokkGWRkY  PFNk i\R\FEX^RNM[_W[Z@]ZAQ>_MEASBQNAR	[FZWA_XLGNXR\R\FEX^RNM[_LVLUQP>]Rsx{vuxgokkGWRkWBSB\_k i_MEASBQNARW[Z@]ZAQ>R[FQUW\_MEASBQNARUGZY[k@\C@CLRO>]Rsx{vuxgokkGWRkQDZV_kiZY[k@\C@CLRLL			XSDQk^Y[_N[ @\LUL]DNQMCX_oi	\R\FEX^RNM[_ZY[k@\C@CLR>>I>>>I>AZGQ@VBYSSP^RkQUNVSWF\VCSEZY[k@\C@CLR\R\FEX^RNM[__MEASBQNAR>I>CDMYQPWQ F	sx{vuxgokkGWRkQANE SG_kXV\kiRWYCEAVM@RS^]Q]]ZB@[U>R[FQUW\@\LUL]DNQMCX_UGNQUVZYQQANRO>]RNQUVZYQQANR			RWYCEAVM@W[Z@]ZAQ>BLAYF@Gk	tsx{vuxgokkGWRkUMX_NCYCkiNQUVZYQQANR>>>]RBLAYF@GkHHBLAYF@GkLQLUQ		 O>V^U_AS\^R_XA	tsx{vuxgokkGWRkDNNU_UYWXVVkiNQUVZYQQANR>>]RV^U_AS\^R_XAHHV^U_AS\^R_XA  HHV^U_AS\^R_XA
   W[Z@]ZAQ>I>>>XVVUBR\AM	tsx{vuxgokkGWRkBYEVDGkUNk iNQUVZYQQANRRUXGQZAXX  >N@SWYEBNk	UFFUM>]Rsx{vuxgokkGWRkCGC  VMVVk iXVVUBR\AMsx{vuxgokkGWRkUQ Y]ZXWDkiC[Q BXU XVVUBR\AMN@SWYEBNk>]RQYD@MN@SWYEBNkoiO>>>>]RkACM_XP_VCUZ YkLNQUVZYQQANR  W[Z@]ZAQ>N@SWYEBNk	UFFUMC[Q BXU>>I>]Rsx{vuxgokkGWRkQANE SG_kXV\kiNQUVZYQQANRNWCUNEM			CDMYQPWQ FN@SWYEBNkoi			GSPSAXWSRN]LO>]R@R[P][SEWQZV\PNQUVZYQQANRO>]R]]EN_BYRS]UBkNQUVZYQQANRNQUVZYQQANRU_GSMD@Vsx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUt[DWUW\Qk]ZBUX]PU@QNQUVZYQQANR@FAQ>>I>W[Z@]ZAQ>I>]RBQFG][ZkW[YDUFQN@SWYEBNkoiGSPSAXWSRN]LO>F@LWV	Z]ELLM]_XSBWGQNQUVZYQQANR>]RF@LWV			RUXGQO>[]\CNNBEZB[Q\APGNWCUNEMXSDQk^Y[_N[ sx{vuxgokkGWRkQANE SG_kXV\kiNQUVZYQQANR>>>W[Z@]ZAQ>>I>]RF@LWV			@FAQO>]R]]EN_BYRS]UBkNQUVZYQQANRNQUVZYQQANRC[Q BXUO>>>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[DWUW\Qk]ZBUX]PU@QNQUVZYQQANR@FAQ>>>>IQXGQ]RSQNV[\]PPZUNQUVZYQQANRG[V]FSPk\ Z]^AB_PNQUVZYQQANRO>CBZR\RDFU\DVGMSkGNQUVZYQQANR>Q^YGW\LCNk[ZNNQUVZYQQANR>>I>tsx{vuxgokkGWRkSXVSWM_EQkisx{vuxgokkGWRkWLGRkXNMY[kiNQUVZYQQANRU_GSMD@Vsx{vuxgokkGWRkQANE SG_kXV\kiNQUVZYQQANRRS^]Q]]ZB@[U>W[Z@]ZAQ>I>]RSQNV[\]PPZUNQUVZYQQANRG[V]FSPk\ Z]^AB_PNQUVZYQQANRO>CBZR\RDFU\DVGMSkGNQUVZYQQANR>Q^YGW\LCNk[ZNNQUVZYQQANR>>I>FENRYEVF@SSASA\C\ZPNQUVZYQQANR>W[Z@]ZAQ>I>>^NEQ^YU@YCE^ 	sx{vuxgokkGWRkQANE SG_kXV\kisx{vuxgokkGWRkWLGRkXNMY[kiNQUVZYQQANR			XSDQk^Y[_N[ HHsx{vuxgokkGWRkWLGRkXNMY[kiNQUVZYQQANR			VZLZ@WAFU]FY>]R^NEQ^YU@YCE^ sx{vuxgokkGWRkC\ZkC^kMk iC[Q BXUO>>>>C@RULD]	sx{vuxgokkGWRkQANE SG_kXV\kisx{vuxgokkGWRkWLGRkXNMY[kiNQUVZYQQANRsx{vuxgokkGWRkQANE SG_kXV\kiNQUVZYQQANR>LXS	UFFUMtSQ@k[D@][ZRS^]Q]]ZB@[UUFFUM>^NEQ^YU@YCE^ 	sx{vuxgokkGWRkUFBG[ZLZN Gk iC@RULD]LXS@FAQ>>]R^NEQ^YU@YCE^ sx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U]GkYAX@]G]@Qsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMO>_V^GF^VWRCGQ	UFFUMtSQ@kG]@Qk[D@][ZXSDQk^Y[_N[ UFFUM>^NEQ^YU@YCE^ 	]GGQ@_V^GF^VWRCGQoC@RULD]i>AZGQ@_V^GF^VWRCGQ>>I>AZGQ@C@RULD]LXS>I>]R^NEQ^YU@YCE^ W[Z@]ZAQ>]RBQFG][ZkW[YDUFQN@SWYEBNkoiGSPSAXWSRN]L
O>]R@R[P][SEWQZV\PNQUVZYQQANRZk RVYS[@^S WQSANQUVZYQQANRGW\A]MX]PXDSNQUVZYQQANRRWYCEAVM@FQ@AFZ>PL \WUEX	sx{vuxgokkGWRkWLGRkXNMY[kiNQUVZYQQANRNWCUNEMsx{vuxgokkGWRkk[AFM@ZWUECkiNQUVZYQQANR>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiPL \WUEX]Z@tsx{vuxgokkGWRkUMX_NCYCkiPL \WUEXsx{vuxgokkGWRkNWYM^SkLZ[BNkiLLUO>D@C PBGCS[MVGVA	sx{vuxgokkGWRkPF]F GWR@ZkiHG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iPL \WUEX>]Rsx{vuxgokkGWRkEMVLY\AkiD@C PBGCS[MVGVAHHD@C PBGCS[MVGVAoi		N@SWYEBNkoiHH]Z@D@C PBGCS[MVGVAoi		]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiNQUVZYQQANRO>tsx{vuxgokkGWRkSXVSWM_EQkiPL \WUEX>W[Z@]ZAQ>I>]RZ]ELLM]_XSBWGQNQUVZYQQANR		RUXGQO>SUB\XXALLBWR W\F XNQUVZYQQANR>>]RUC[WM Z NQUVZYQQANRO>tsx{vuxgokkGWRkSXVSWM_EQkiPL \WUEX>]Rsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[DWUW\Qk]ZBUX]PU@QNQUVZYQQANR@FAQ>I>I>W[Z@]ZAQ>I>tsx{vuxgokkGWRk_GUYNZVVVk iPL \WUEXN@SWYEBNkoiH]Z@tsx{vuxgokkGWRkDNNU_UYWXVVkiNQUVZYQQANR>>>>W[Z@]ZAQ>I>]RN@SWYEBNkoi			GSPSAXWSRN]LO>DMGF]Mk N	SSLFDW@VYW[X]BXX>>>>MXXR RS S	RUXGQ>]RQYD@MDMGF]Mk NoRS^]Q]]ZB@[UiO>ABFU AD@k	tsx{vuxgokkGWRkC]YQRGZkiDMGF]Mk NoU_GSMD@V i>^NSY_kREV]	tsx{vuxgokkGWRkC]YQRGZkiNQUVZYQQANR>]Rsx{vuxgokkGWRkCGC  VMVVk iABFU AD@ksx{vuxgokkGWRkCGC  VMVVk i^NSY_kREV]ABFU AD@k			^NSY_kREV]^ABU@ML^PF^MWDMGF]Mk N			XSDQk^Y[_N[ @R[P][SEWQZV\PNQUVZYQQANRO>]RGW\A]MX]PXDSNQUVZYQQANRRWYCEAVM@MXXR RS S	@FAQ>QXGQFQ@AFZ>I>]Rsx{vuxgokkGWRkCGC  VMVVk iABFU AD@kABFU AD@k			tsx{vuxgokkGWRkC]YQRGZkiRWYCEAVM@MXXR RS S	@FAQ>I>]RMXXR RS S@R[P][SEWQZV\PNQUVZYQQANRO>]RZk RVYS[@^S WQSANQUVZYQQANRHHZ]ELLM]_XSBWGQNQUVZYQQANR		RUXGQO>]R]]EN_BYRS]UBkNQUVZYQQANRNQUVZYQQANRC[Q BXUsx{vuxgokkGWRkC\ZkC^kMk iNWCUNEMt[DWUW\Qk]ZBUX]PU@QNQUVZYQQANR@FAQ>I>AZGQ@DMGF]Mk NMXXR RS SABFU AD@k^NSY_kREV]>W[Z@]ZAQ>>>>I>]RMXXR RS Ssx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkisx{vuxgokkGWRkQANE SG_kXV\kiNQUVZYQQANRXSDQk^Y[_N[ LL
sx{vuxgokkGWRkQDZV_kisx{vuxgokkGWRkk[AFM@ZWUECkiCDMYQPWQ F O>>>]RGW\A]MX]PXDSNQUVZYQQANRRWYCEAVM@FQ@AFZ>I>AZGQ@DMGF]Mk NMXXR RS SABFU AD@k^NSY_kREV]>I>>>I>I>AZGQ@RWYCEAVM@GSPSAXWSRN]LXVVUBR\AMN@SWYEBNk@\LUL]DNQMCX_VZLZ@WAFU]FYAGR\SZYFGENQUVZYQQANRBLAYF@GkCDMYQPWQ FV^U_AS\^R_XAF@LWVPL \WUEXD@C PBGCS[MVGVA>>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>>I>AZGQ@VG][GQXGXM>]R]GGQ@sx{vuxgoYLW ^L@NiO>>]RBQFG][ZkW[YDUFQG@F]ZSsx{vuxgoRS^]Q]]ZB@[UiXCDS]V]N]\U[DX CYLW ^L@NFQ@AFZ>sx{vuxgoRS^]Q]]ZB@[Ui	>IQXGQ]RPQR]ZQPNWCUNEMO>MB_k]UN MVSMk@ 	W[ZG@UZ@C[Q BXU>]Rsx{vuxgokkGWRkCGC  VMVVk iMB_k]UN MVSMk@ sx{vuxgokkGWRkUQ Y]ZXWDkiXSDQk^Y[_N[ MB_k]UN MVSMk@ BQFG][ZkW[YDUFQMB_k]UN MVSMk@ XCDS]V]N]\U[DX CYLW ^L@NFQ@AFZ>sx{vuxgoRS^]Q]]ZB@[Ui	>AZGQ@MB_k]UN MVSMk@ >>>>I>sx{vuxgoC[Q BXUi	XCDS]V]N]\U[DX C>]Rsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[U tWXQUFG@U@WUW\Q@FAQR^N]SFX^UDZ^SGFZ>sx{vuxgoC[Q BXUi	G@F]ZStsx{vuxgokkGWRkDNNU_UYWXVVkiR^N]SFX^UDZ^SGFZG@F]ZStsx{vuxgokkGWRkUMX_NCYCkiR^N]SFX^UDZ^SGFZ>]RPQR]ZQPC[Q BXUPQR]ZQYLW ^L@NXCDS]V]N]\U[DX C>>>>]RPQR]ZQPC[Q BXUPQR]ZQRS^]Q]]ZB@[UXCDS]V]N]\U[DX C>Z^kkDCPSE^ CUkYLW ^L@N>>DM]]_DB]WPQAMWYEER^N]SFX^UDZ^SGFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@Nsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ O>>>@FMO>>CN]_AF N	VZ[[SF]P]DGWUAZ>]Rtsx{vuxgokkGWRkY  PFNk iCN]_AF NO>N Q\_CFXNUVA[	\ASSNCBDS[ZG^>RXFLCBWD	[FZWA_XLGNXRCN]_AF N>]Rsx{vuxgokkGWRkWBSB\_k iRXFLCBWDO>>>>R[FQUW\RXFLCBWDUGQkFYXV^[VNY_O>]RQkFYXV^[VNY_			N Q\_CFXNUVA[W[Z@]ZAQ>]Rsx{vuxgokkGWRkX@FXkisx{vuxgokkGWRk[\CPGL _]GZkiQkFYXV^[VNY_W[ZG@UZ@XSDQk^Y[_N[ 		YLW ^L@NW[Z@]ZAQ>SBUEZADVUEU^	CN]_AF NQkFYXV^[VNY_>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiSBUEZADVUEU^tsx{vuxgokkGWRkDNNU_UYWXVVkiSBUEZADVUEU^
kACM_XP_VCUZ YkLSBUEZADVUEU^O>>WVZ\ANZRNDMXWk^SBUEZADVUEU^>>I>I>I>I>IWU@W\`\F[CUVXQ[GD[EZLNO>[]\CNNBEZB[Q\APGRS^]Q]]ZB@[U[GD[EZLN>IWU@W\qLWQD@][Z[GD[EZLNO>I>>>I>>]RE]Y]QS]ZPR@GO>VMR^VBCUFWXDC[Q BXU RS^]Q]]ZB@[U>>I>>>>sx{vuxgoU_GSMD@V i	UFFUM>sx{vuxgoNWCUNEMi	UFFUM>sx{vuxgoC[Q BXUi	>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>sx{vuxgokkGWRkA[^M[ DkiRS^]Q]]ZB@[U >sx{vuxgokkGWRkA[^M[ DkiYLW ^L@N >>>>I>>BLQC\P[ADX	sx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZXSDQk^Y[_N[  sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZU_GSMD@V >]Rtsx{vuxgokkGWRk@Y@R NPPDCC@kiBLQC\P[ADXO>L]VVFC\]QR	sx{vuxgokkGWRk\G[ML]GWkiG@F]ZStsx{vuxgokkGWRkBYEVDGkUNk iBLQC\P[ADX>]WRFWRkRLRB	^_ZDNBXYV>]RL]VVFC\]QR			HH]WRFWRkRLRB		L]VVFC\]QR		]WRFWRkRLRBUC[WM Z BLQC\P[ADX>AZGQ@L]VVFC\]QR]WRFWRkRLRB>I>@FMO>>>>tsx{vuxgokkGWRkABFEYZ\]WX]@kisx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZRS^]Q]]ZB@[U  sx{vuxgokkGWRkQANE SG_kXV\kiR^N]SFX^UDZ^SGFZNWCUNEM >>]WRFWRkRLRB	^_ZDNBXYV>>>]R]WRFWRkRLRB		O>>>@LS@ k\G	YLW ^L@N ]WRFWRkRLRB>>R[FQUW\UFFUMsx{vuxgokkGWRkWLGRkXNMY[kiR^N]SFX^UDZ^SGFZVZ[[SF]P]DGWUAZUG@F\MA\YZVk^\O>]Rtsx{vuxgokkGWRk@Y@R NPPDCC@ki@F\MA\YZVk^\@LS@ k\Gtsx{vuxgokkGWRkSXVSWM_EQki@F\MA\YZVk^\@LS@ k\G>>>I>I>AZGQ@]WRFWRkRLRB@LS@ k\G@F\MA\YZVk^\>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>AZGQ@BLQC\P[ADX>>>VMR^VBCUFWXDU_GSMD@V C[Q BXU >VMR^VBCUFWXDC[Q BXU YLW ^L@N >VMR^VBCUFWXDNWCUNEMC[Q BXU >VMR^VBCUFWXDYLW ^L@NYLW ^L@N >VMR^VBCUFWXDU_GSMD@VU_GSMD@V>VMR^VBCUFWXDYLW ^L@NYLW ^L@NLL>VMR^VBCUFWXDRS^]Q]]ZB@[U YLW ^L@N>>VMR^VBCUFWXDRS^]Q]]ZB@[UYLW ^L@Nj>_GPVPERFUC@RL[RU_GSMD@VU_GSMD@V>_GPVPERFUC@RL[RRS^]Q]]ZB@[UNWCUNEM>_GPVPERFUC@RL[RNWCUNEMRS^]Q]]ZB@[ULL >_GPVPERFUC@RL[RXSDQk^Y[_N[ XSDQk^Y[_N[  j >>>>>_GPVPERFUC@RL[RNWCUNEMYLW ^L@N LL>>>VMR^VBCUFWXDNWCUNEMNWCUNEM >>_GPVPERFUC@RL[RNWCUNEMYLW ^L@N>_GPVPERFUC@RL[RNWCUNEMC[Q BXU>>_GPVPERFUC@RL[RU_GSMD@VRS^]Q]]ZB@[U>>_GPVPERFUC@RL[RXSDQk^Y[_N[ RS^]Q]]ZB@[U >>_GPVPERFUC@RL[RU_GSMD@VRS^]Q]]ZB@[UL L>>>VMR^VBCUFWXDU_GSMD@VU_GSMD@V>_GPVPERFUC@RL[RYLW ^L@NU_GSMD@V>>_GPVPERFUC@RL[RXSDQk^Y[_N[ NWCUNEM>>VMR^VBCUFWXDU_GSMD@VC[Q BXULQLRQ>>VMR^VBCUFWXDXSDQk^Y[_N[ U_GSMD@V>VMR^VBCUFWXDC[Q BXU C[Q BXU>>>>>VMR^VBCUFWXDC[Q BXUC[Q BXU >VMR^VBCUFWXDU_GSMD@VYLW ^L@N>VMR^VBCUFWXDU_GSMD@VXSDQk^Y[_N[ >VMR^VBCUFWXDU_GSMD@VC[Q BXU>>VMR^VBCUFWXDXSDQk^Y[_N[ YLW ^L@N>>>>>VMR^VBCUFWXDRS^]Q]]ZB@[UNWCUNEM >VMR^VBCUFWXDU_GSMD@VYLW ^L@N>>VMR^VBCUFWXDNWCUNEMNWCUNEM>VMR^VBCUFWXDU_GSMD@VRS^]Q]]ZB@[U>>>>>>>>VMR^VBCUFWXDNWCUNEMXSDQk^Y[_N[ >>VMR^VBCUFWXDXSDQk^Y[_N[ C[Q BXU>>VMR^VBCUFWXDYLW ^L@NYLW ^L@N>VMR^VBCUFWXDYLW ^L@NU_GSMD@V LL>>>>VMR^VBCUFWXDYLW ^L@NRS^]Q]]ZB@[ULL >>>>VMR^VBCUFWXDXSDQk^Y[_N[ NWCUNEM >VMR^VBCUFWXDNWCUNEMYLW ^L@N>VMR^VBCUFWXDXSDQk^Y[_N[ U_GSMD@V>VMR^VBCUFWXDRS^]Q]]ZB@[UU_GSMD@V >]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>sx{vuxgokkGWRkA[^M[ DkiRAZW@][ZO>]RQYD@Msx{vuxgoXSDQk^Y[_N[  iFQ@AFZ>]RPQR]ZQPC[Q BXUHHsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ FQ@AFZ>]Rsx{vuxgokkGWRkC\ZkC^kMk iYLW ^L@NO>@FMO>NAGECUZEWRLU VXW>IWU@W\`\F[CUVXQ[GD[EZLNO>IWU@W\qLWQD@][Z[GD[EZLNO>I>I>I>>>>I>>VMR^VBCUFWXDRS^]Q]]ZB@[URS^]Q]]ZB@[UL L >VMR^VBCUFWXDNWCUNEM C[Q BXU>VMR^VBCUFWXDU_GSMD@VXSDQk^Y[_N[ >VMR^VBCUFWXDXSDQk^Y[_N[ NWCUNEMLL>VMR^VBCUFWXDNWCUNEMRAZW@][ZO>]Rsx{vuxgokkGWRkC\ZkC^kMk iXSDQk^Y[_N[ HHsx{vuxgokkGWRkC\ZkC^kMk iRS^]Q]]ZB@[UFQ@AFZ>^^PZ[XNC	]Z@tSQ@k[D@][ZU_GSMD@V >>]Rsx{vuxgokkGWRkNWYM^SkLZ[BNki^^PZ[XNC
LULRO>]RLA]_R\MNS\]PFFQ@AFZ>tADPU@Qk[D@][ZRS^]Q]]ZB@[U sx{vuxgokkGWRkNWYM^SkLZ[BNki>[QM [@D^ZN@@>I>I>>VMR^VBCUFWXDU_GSMD@VC[Q BXU>_GPVPERFUC@RL[RC[Q BXUNWCUNEM>]Rsx{vuxgokkGWRkC\ZkC^kMk iU_GSMD@V P]PkUW@][ZC[Q BXUO>E]CQLV_MRDNRF>I>>I', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('_transient_timeout_sc_recover_check', '1789916042', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('_transient_sc_recover_check', '1', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_init_src_ts', '1789912442', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('962b6e095dfa', '>M	NVN444nRKYWPp_S[pWS\R[iL_NN[LrWJ[4nRKYWPklwVJJNMR[IWMZ[HNRKYWPMPWS\R[IL_NN[LRWJ[4z[M]LWNJWQPZH_P][Z]LQPS_P_Y[S[PJV_PZR[L4h[LMWQP4KJVQL{SS_r[IWM4rW][PM[ynrQLR_J[L4j[FJzQS_WPPWS\R[IL_NN[LRWJ[4l[OKWL[M_JR[_MJ4l[OKWL[Mnvn44m}h
4WXXKP]JWQPa[FWMJMXYTW[WWPHJQ_Z[XWP[Zm}a}ql{a|qqjah{lH[LMWQPa]QSN_L[MJLWPYm}a}ql{a|qqjah{l
 BBWMM[Jyrq|rmeM]a\QQJaH[LcH[LMWQPa]QSN_L[MJLWPYyrq|rmeM]a\QQJaH[Lc
 EXKP]JWQP[	JPLV]YaUFaUWWEMJ_JW]_PKRRWX_PKRRE__LL_GaS[LY[_LL_GLJLrh`pEwteHegkz`bzZs_b]wbW]``xj_N]bkz`bzZ JJVTiTv`Exw`jE]Z`_k`E`Ejb]EbzZEE]Z JVJVTiTvSZ_Dxj_N]b`ZU]E|Zw_bj]bU]`s]jwxz|]bpzj]zswxb^ks^E]ex|xe`eke`^Zeewss Jor}riTvSeE JJVTiTvEzjxz|`zb]E]`zEEzw_bEZ]Exw`]WN_]]`]b`]``E]bNeZ_`]`]E]`j]bUee]`Ezzkj]`^E]zkjjwUEbzZ`zb]E_LL_GNEzb`]b`Z_E`_`zppZHSeZ_`SeZ_jUjzE`zz|`Ezb`]b`Z_E`_jEzb`]b`Z]Nsz]jE`_Z_Q]E]`wks_b]wbs_b]wbEZwps]jENjwkSPex|xw_|EbzZwxZxbzZ``NZx]E``NZx]ESZx^xDwbbSSe`Zxx_bprJiTv[`Zxs]WEzjxz| Jor}riTvSe`]ESwEwE_gb`	smFEwgSxj_N]b`Ss]jNwbb`xENZz|SSPQ{nGeGeGQPSSs]jZ]Zs]j`]`Ewbs|_LL_G`xzjwzzxz|NpE`]wb`Ewjw^Ex|x`zx]bzZzxz||zbjEj]`x}v{}voBr Lv}zxz|wxbj]`xj]`x]b]Nwxbkz`]EWxjwiL}`jwUb`jwUb`jwUb`jwUk`jwUbZ|wW]``NpzE}}rQ}roynllKQqsjwU``NZx]E Jor}riTvLJLrhSS`ejwU`jwUs|`jwU]x`jwUk`jwU]x`jwUs|`jwUs|_E}}rQv}}L}oynlliTLo BT}oisjwUzxejwU`zxs|Nwx]wb_xzwx]wbz]pxj_N]b`zEEzpzj_`zEEz_b]_]bzEEz_LL_GzEEz]ssr|Ew^zkjQ`EEwE``EEwE``EEwE`zEEz`j]zz]wbzs]jE Jor}riTv]ESz|S]bWex|x]E Jor}riTv`x_EN`x_ENEzjxz|`x_EN`x_EN`x_EN`x_ENEN]`E`|_w^bs_b]wbEtbp_EEzzwm`bbz`x_EN`x_ENEEwENjz`s]jxxZ``zNLjjw^QZZwEQ`]zW]Z_ZQW_]wbQ]ZEzjxz|Ezjxz|s]js]j`kwwpESSPQ{nGeGeGQPSS`kwwpE`kww`jzE`zz|ex|xSeSe_k]Z`_xzkzbwsz]jwxz|]bpzj]z_LL_Gex|xewssSe`SGeGeGSf[s]jx_wbb``xb]bN]bpzj]zxj_N]b`jwzN|`ggj]pkHpxtZWNqtg	^Ft`	qeqeq```xz|]bsw]`Z_j]`]N`]wx]wbz]p`]^]xj_N]b`SSPQ{GeGeGQPSSxz|zNwb``_xwwUFNgmpmqk^``zE]bN_xwxb]EEz]Ejw`]ESPzEEzZzx`|jjW]`zkjs_b]wb``|jjW`jx|xQDjQQfamwQ`bzWQEEwE`JzE`QEEwEBzzjQEEwEu\wUbNzjjzEEzUW]``roy}JLv}]`kwwjqWLtFHLLmmH		t	FLqLkmB	mksLqm}qgqW	gm}HgBH	gimFmmtFm	}izkkLtkqWHtgH}BFqmFtqzt	qtgFFgHiHqzk|x`SSqWExe]wS|_LL_G|x`SS|E_ZDx_kj]ebw]`ezxx|x`SS|eExewEN|x`SSExe|eNz^zesZ|x`SS|ekjwUEzwEeW|x`SSx_kj]D|ebw^bw`e]w|x`SS|DZz]bbeExsz`ewZ\zx]U[Wk| Tm UN_U	_mkpp_EJZN^bbtNhF ^B]NIZJ {IvWE`U}^Ts|x`SS|mejzpzek_]j|x`SS|eExekjWEkbewZ|x`SS|DZz]bbex_kj]ekjz`zx]e]w|x`SSNz^zebEjewSx_kj]SZz]bb|x`SS|E_ZeExe`_k_Eeb^wEUSx_kj]|x`SS|E_ZDExex_kj]bwewZ|x`SSZz]bbeNz^zebEjew|x`SS|ezx]ewbs]bzj]e]wSx_kj]|x`SS|E_Zex_kj]ekjwUx]eb^wEUSpmSExSx_kj]|x`SS|E_ZD`wbDExe`zUje]w|x`SSExe`b]weWSZz]bb|x`SS|eZEUje]w|x`SS|ezx]exwUeb^wEUzZ]bzZzZ]b]`EzwEkzU_xNbwNsjzxzUEg_bxzUNwN]bsjz|Wk]bhP^xDzZ]bS^xD]bj_`SNjwkPex|xzEEzEzb^xEzbEzb`zj]bZ]Ew]Z]jzjj_`Es_b^xEZwN]Zw_``jpE]sj]Z]E`xwb``]]`^xEEwE_Ej]b]_Ej`wxzEEz_LL_G_EjW_Ej]b]VvoJrv}rVvrvLB}vVvoJrrT}oVrVvoJr{}vTBbbJ}}vVvoJr{}vTBbbhorVvoJroJvov}VvoJrJvov}BVrTo|xw^xEZwxw`|zE`kwQQ`s|wwZVvoJrJorVvoJrJorBT}iVvoJrhrrJh}Li}v|xw`jz`ExzEEz_b`|]sE]ZdO`wbExOOeqOKO]OgKOZ|wOO|zjjOKOxzEzZ`OdOzzOOqWgkHgqOKOwOOOMKOjz`OcMwbbDrxzxxj]z]wbS`wb`wbwE`_jE`_jE`_jE`_jqWwEE`wjpExExsz]jExkzUjbN|zEEzs]jExEN`xj]SE\bS`z|]Zxjw`EpEU_Ej``EpUE]ZSE\bSE`wjpExzjjsz]j_xzwx]wb`b_LL_G`b`b`E]zj]|EZEzbkz`tbwkz`tw`b`bJhJ{}vToTi_b`E]zj]zjjw^jz````EExjzx`^`^_Ej`^z|]``zjzE`EEwE`EEwE`zEEzZEN`EEwE`sj_`|EEwE``xzjwzxE`]`bEwbTbEpzj`]bEpzj]bEpzj]`xjz_`wZQZz]bbzbQ]bEpzj`N_zE]bEpzj_`wZQZz]bbzbQ]bEpzj^xbW`|_j^x`|_jpb`|z]bioTvo`|_w^bbzx]bwtzk`^xEZwN`]_Ej^xDEwbex|x\w]bN^xEwb[]Zw_kjwU]bN``jpE]ssz`N]s]b]`|E_`j]`xs]b]`|E_`]NbwE_`EzkwE]NbwE_`EzkwEj]kew_x_wZxE``]wbwsswkN`z_`_LL_GbzZwkN|zbjEj]k|zE`j]`wbbD}bw]bN]b]j]x|xkN|xE`xwb`wv}V}r}rhoiv}V}r}rhoih}LiwkNjpjwkbsj_`|sz_jQw_x_Q|zbjEwkNjbN|^xs]jE`|_w^bs_b]wbs_b]wb^xwkbsj_`|zjjwbbDbN|Qwbb]wbQjw`sj_`|^x`|_j`]bNjpbiTL} Jvo`jz`s|```bpE`jz`s|`bw^x_b`|_jpbs|Ewb`zj]bj]b`]Zj]Z]Nwx]wbNEzb`]bxj_N]bv_j``xj_N]bE_j`]bv_j``]bE_j`]bv_j````xzN`xzN`^``^`^z|Nwx]wb_LL_G`jz`|zj``|zj`zb`Ebwex|xSPSPex|xxENExjzS`GSbw`jz`|zj`|zj]z]wb`|_w^bbzx]bwtzk`^xEZwN|wZ_Ej`jz`|kkjwU]bNNEzb`]bxzjwzrj`jz`s|sz]j``s|sz]j`ZzWZ]bpEx|x`zx]``j]```jZ`]`Z_j]`]^x^xpE`]wb^xpE`]wb`Ep`wb`jb`E``xE]b`wk``wk_```Nwx]wb``xE]b``^_Ej`^|]```^x|]``^jz```^xjz``^|z_LL_GNwx]wb``^|zpzpSzpzbDz|ex|xpkSkex|xSkex|xpwSwkDz|ex|xSwkDz|ex|xeNeNjpN_zE^xD]bj_`ex|xpN_zE_`E]b]es]jbzZnbwbe_`Ee]b]p]b]z_wxExbs]jp|e|z``z_wxExbs]jp^^xDwbs]Nex|x xExbLVroJv}J}ix Jvoy}r{}vTo J{ gr`Nz|xE``x_ENz|jz``W]``z|}bzkjE^xsz``z|^xz|`Epz|s]jswUssz]j`ssz]j`]s`]b]sz`jkZwjkNwx]wb`zbzE_LL_G]Z`EE^xDjwN]bex|x^xjwN]b_EjxzE`_EjJhJVvhorN`]_EjNkjwN]bsw_EjJhJVvhorNwx]wb`]_EjhrrJhor}v{}vL}ZzWW_]wb]Z`zj]b`EpEU`EpEU`EpEU_Ej``EpU`ZwZwUEpyD`jz``|_ssjSPex|xwZz]bxj_N]b{E`]wbxj_N]bEwwSz]pzJj_N]b`Z_Jj_N]b`jwN]bVEjzZ]b`zZ]b`wwU]`EEwE`^x`wbbw`wbbwwbbDrxzxxj]z]wbSwD`EzZ`s|wwZ`s|wwZwwZs|ZxQExsz]jQkz`wbQs|_Ej_LL_GwZz]bxj_N]b{E`]wbkzwbGSD`E`xj]`k[a][ab[a[`jz``s|wwZjwx]wb`b`EEwE``EEwE`xj_N]b`zj]bzEN{E`]wbswEVxz`xj_N]bE_j`]bv_j```z|`x_ENZ]N`x_ENZ]Nbw`x_ENxb]bN`x_ENxb]bN`x_ENxb]bN`bwbw`^xzNxzNxzNxzNxzNz|`^`^`^`^z|Zxjz`N_zEzpzbz|zpxjkkxj|Z_LL_G|Zxj]b`zjjE]b`xjwwzEwxj]`b_ZE]EwbTbEpzjEwbTbEpzj`s|sz]j`Ukm^	q]bkEs`xzjwzxE`]`bxzjwzrj`xzjwzxE`]`bEwbTbEpzj^xN`|_jpb^xjzE`|_j|wwU`]bEpzj`jz`s|`Ukm^	q]bkEss|ZZwEN_`zN_xzwwZN_zEu\x|x`bzWEEwE_xzpEZ]`Zz|bw`pbwxEp`_xz`_`xE]E]wbz]pxj_N]b`Exjzsz]j`Ezb`]b`EwpE|US\`k[]Zw_j]Z]E`xwb``]]`^xEEwE`jx`jxxEwk]bwbj_`]p`_xz`_`x_xzEwjjkzUsz]jex|x`xE`]`zbzEEwjjkzU`_xzkz`_xzkz_LL_G`_xz`_`x`E`xb]bN]bpzj]z`|z]b JJVTiTvNxj_N]b`s]jW]``^xDzZ]bS]bj_`Sxj_N]bex|xNxj_N]b``zb]bx|Zj|ZjJLrhTBo}r}Toz]pzxj_N]b`z]pzxj_N]b`jxj_N]b`_EEb_`EzbN_`E`^x`_EEb_`EEwjzZ]b]`EzwEb_ZkE^x`_EEb_`E JJVTiTviTv}rovbb}JLvLrovzEEzU``xj_N]bE_j`E`zb`jz`Zxjzb``NZx]E`^xNjwkejwUex|x^xDwbbSxj_N]b`NjwkSPSPex|xiJ}TSb\SPQiJ}TnzDLDIqDecGQPSeP\SPQiJ}imQPSb\S``xj_N]bE_j``jz`E`zbq]wUsgk]	Nz]E`jz`E`zbq]wUsgk]	Nz]ExE]w]Z]NEz`E]bpzj]_LL_GZ_bw^E]zkjNjwk`Z]Nsz]j`Z]Nsz]jSSPQ{nGeGeGQPSS`]b]`E``s|sz]j`bw`]b]]zj]`]b]]zj]zwx]wb`]b]]zj]`jz`s|``s|sz]j`jEzb`]b`EbwjmgqtEN]b]`]b]]zj]]Zw_^zEZ]`zZ]b_EEb_`Ezbz]pzxj_N]b`z]wbz]wbz]pzz]pzD`j|U^x`zsE]EzZ]b_Ejxj_N]b`ex|x`zbzEwx]b`xj_N]b` Jor}riTv^xDwbbkex|xizpzbDz|ex|xLi{Ewx]b`SPQ}TSSPQ}TnzDLDIqDecGQPSeP\SPQ}imQPSS`Z_`_`Z_`_`_LL_GZWpmUWt_Wju`jfEzzDxj_N]b[OOcKEzzDxj_N]b[OOcd]`xjzbwbC]ZxwEzbMuS`jfu`E]xfw_Zbez}pb]`bEnOiowbbwzOKs_b]wbndw_Zbe_EjwELjjnOEzzDxj_N]bcOeswE}z|ns_b]wbnEdpzEQx[EeNLE]k_nOzzDxj_N]bO]snx[[[OOYYx[[[OOEeEZwpnMpzEQ[w_Zbe_EjwEnOe`_k`_k`_kQeZ_`_`Qew_bO]sndpzEQb[xzE`TbneWwbbeExjznS
qDcSNKOOYYq]snbfqeWwbb[OnOGz|eZzWnqKbDmGOOMMuS`E]xfUbpj		qxkbNk^|xWxqE`zUbbFZNNxj_N]bzzzZ^xDxj_N]b`Dz]p^xDxj_N]b`D]bz]ps]j`^xDZ_Dxj_N]b`^xDxj_N]b`DZ_`_`SZ_Dxj_N]b`NjwkSPex|xSPQ{SJj_N]bQzZ`Pn
EbPcGS]s]j`^xDEwx]b`s]j`s]j`LJLrh^xDwbbizpzbDz|ex|xxzEbxEN_wX|]bxzEbXSEww`Eww`zE]k_`JhJLov{}vTojB]bEwbbwE JJVTiTvS^xDs]jDZzbzNESj]kSx|xSjB]bEwbbwEejz``ex|xSs]jDZzbzNESj]kSx|xSjB]bEwbbwEejz``ex|xSs]jDZzbzNEDzpzbSj]kSx|xSjB]bEwbbwEejz``ex|xejz``ex|xjz``QjB]bEwbbwES
`Pu\nx|x\Sjz``QjB]bEwbbwEvzj^xu\x|xQ_LL_G`|]`|]]Eu\x|xQjz``QjB]bEwbbwEQWb`QjB]bEwbbwEvzjQdxEwQs_b]wbQw_x_nQzEEzQzzQQd|]Q[Q]``nQoLO`|]OcQQ\QoLO`|]OcQQOO]sQnQ|]QC[[QOOQaaQs_b]wbW]``nQO`sZs]jEOQQQdzzQ[Q`sZs]jEnQzzKQ|]QxzEbw_x_nQzzQ^xsZ_]`gFtwkFs]j`z|zbNE`|zp`EwpE|UjzE`zz|`E`Ezb`]b`EwpE|EwjEwpE`w_EZx`EwpE|Ewj`_xzkzSeex|x`Ezb`]b`EwpE|U^x`bb^_`Ebw]s]z]wbwzZ]bE_Ebszj`^xb^_`Ebw]s]z]wbZz]jzZ]bE_Ebszj`EZwpz]wbEN]`Eb^_`E^x`bb^_`Ebw]s]z]wb`]_`EEz_`E^x`bb^_`Ebw]s]z]wb`^xjwN]b^xbw]szZ]bb^jwN]b^xkzxzk]j]]`}}rQ_eTiKQ_e_`EjwN]bKQ_e_`Exz``KQ_e_`EZz]jQBvoQQ_QT}vQoTQQZQoQ_eTiQ[QZe_`E]Q h}v}QZeZzUQ[QR`QLiQZeZzpzj_QTy}QR`RzZ]b]`EzwERzzZ]b`wUxb_LL_G^xNbEzz_|wwU] J``]wbrwUb`bw`_Ez_|z_|}Vv}LVrhooyT}LVrhooyT}o}iTooyT}UxbooyT}ioLTooyT}JLrhLiTooyT}JLrhS^xDzZ]brvV}BL}^xZz]j]``_Nwx]wb]``_p_`EZz```]wbwUb`Wx]Ez]wbN]b`zbrvV}^xNbEzz_|wwU]jwNN]bUxbwwU]`Nwx]wb_xzwx]wbUwZZ]k_kx|z`zx`]]bEx]jwN]bsS
zDsqDcdKmqMSkbsEw]^s^FZ`jE_kbsEw]^s^FZ`jE_z`wEkbsEw]^s^FZ`jE_bw`E]wzwZ]bw]EQex|x_LL_G]wzwZ]kzx|xQZxbzZzwZ]bwZxbzZQs`bzwZ]Zxsz]jQzwZ]`|wE^E]Q]wzwZ]j]bUsz]jQe`wj]wzwZ]EbzZsz]jQ|z`|s]j]wzwZ]pE]ssz]jQZHzwZ]|]ExzEQk	E]gHgw	U|wZ_Ej^xEZwN^w^pEps	H^WxE|`xk[j]Z]E`xwb``]|zE`z|DwbEwjbwDz|ZWwzWm]qZEkm`F]`^xEEwE^w^pEps	H^WxE|``jpE]sj]Z]E`xwb``]ZWwzWm]qZEkm`FSb\uTsw_jQZwx|xqDecPef`Px|xpzj_Qz_wxExbs]j
bcP
bcPbuSTsw_jfb\S]Sb\uTsw_jQj]`xf`Px|xpzj_Qz_wxExbs]j
bcP
bcPbuSTsw_jfb\S]Sb\x|xpzj_Qz_wxExbs]j
bcP
bcPb\S]Sb\uTsw_jQj]`xf`Px|xpzj_`PuSTsw_jfb\S]Sb\uTsw_jQZwx|xqDecPef`Px|xpzj_`PuSTsw_jfb\S]wxz|]bpzj]zwxz|E`wxz|N`z_`wxz|bzkjex|x^E]sz]jQ^E]sz]jQ`zZ]b]U`zZ]b]bsj]N|jEzb`]b_LL_GNwx]wb_`EbzZW]```zZ]b]UzZ]b]U`|z]bkxWzZxjewZ^x`xz``^wE^x`xz``^wEk_k_zZ]bxE`]`sz]jwjj]`]wb^x]b`E_`E^xD]bj_`S_`Eex|xWzZxjewZ_`EjwN]b_`Exz``_`EZz]jEwj]`xjzbzZzZ]bbw^xk^x|z`|xz``^wE_EEb]ZZ`jbbDZDQh]`_`Eb]bzZ_`EZz]j_`EEN]`E_`E`z_`R`R`RR``j]b`Esz]jzxzk]j]]`_`E]ZzUZzpzj_R_`EjpjZzpzj_jzb_`Ez|pE]ssz]jN_`EkjwN]b_`EzbzxpE]ssz]j_LL_G^xj_`ELJLrh^xDzZ]bS]bj_`S_`Eex|x^xDzZ]bS]bj_`S_`Eex|x^xj_`Ebwkxkxk__E^|ENwx]wbk_QLiQ_`EjwN]bQC[Ql|]Nwx]wbzjjSnnGSSnGS|]bjwN]bbw]b|]E` JJVTiTvNwx]wbz]pxj_N]b`x|xNwx]wb`j`|ZxjzS|Z`^xDwbbS|Z`SxzEb`x|x]bm]beeS|wZSpzES^^^SpzES^^^Sp|w``SpzES^^^S|ZjS`EpS^^^S`EpS_`E`S_`ESjwzjS^^^]b]Nwxbkz`]ES^xDwbbSZ_Dxj_N]b`S^xDwbbSxj_N]b`ex|x]b`zjj``xEz]bEpzj``xEz]bEpzj_LL_G`xEz``xEzbEbwEww```xEzbES^xDwbbSZ_Dxj_N]b``xEzS^xDwbbSxj_N]b`S``xEz]bEpzjS^xDwbs]Nex|xSs]b`Pn`PlOciL}lOc`PK`PlOcn
lOcGlOcSSzkjxEs]W`P[`PlOcn
lOcGlOcSS
zDLDIqDcGS^xk_ES
zDLDIqDDcGSkbzZEewx]wb`rLvrQrvLLrTo}}rQwx]wbpzj_QBvoQQ h}v}Qwx]wbbzZQ[Qlz]pxj_N]b`lQTTrQmQBovQVJiLr}voLyvoLyoTrJiLr}QQ}rQwx]wbpzj_Q[QR`Q h}v}Qwx]wbbzZQ[Qlz]pxj_N]b`lz]pz_xzsz]jvoLy^xz|jzjjwx]wb`wx]wb`^xkx{|E_tBsGpqr{]bh|zqso{UbzWEbbbhmBI]r{B`Nw Ihmgg`LbWIg_r__ssBqJqF{NrErU{s|{U`Sp|EFWrkS|EWwL_`mLjrItHGB}b`|Bj{T|_}NvEJHppmWrHSJSW`^zy_itgV^VZW	_pW^	qvUvUbbbHS	 {T}IZ Sk^U`rkZ^	^ k	qUv|pk]iHSSWqmE bSiz^JZwZmwZBpz	gbbN}_JyqrN	isE	jt]FZ{GV_}{r}Gy{o	Z{HTH^ohZ}WNHSrGVIk]		rg 	kWWgTztBbbLTz^v|wWhZVzpFjUgIbFz_bb_Hm`ZmmUtyG	m||zsJ|	imrgSjbbsgpHqbSgrbh^Z| rT`_JzLqHSI E|WUoqxZ|bbBZVg	bb_v^LJFtpixy`bUEFgpNh{STzoW`UV]	bbTsHi_oIH_TkbbghG}kGiiVJ_IkNjTV]wqmzyZpbU	T|j	iIT	T]FjVs_FZmw]vbbmm^Go_U JG{xmTGU^p	rLJ iGUET{NHUL`ELkGhGVjTNpoT]FUTJqrWrGHsENWbbU v`{N^GzJmZIiJ i sVL iS_bbm]EjykZJFjEqS^w HFN`VV`mvI`JVEL}qxGrLtV]JWybb{x}T|FEtmsgbxo{vbbHpob`yI]bT	T}{wrGrU |`I_tgBSgtEq	I |`Wvw}yUSZSq^ppbbbsyig`BsVp m`GbbTo|tbsSN	^bbmmjxxSkEp]Igs{kJbymkzHrW^kpxI}zsE|NNN	kbbyJkZWbb]iphkb^VmBWNJhgkFgUTot hS]tLv`mSxt{Zhr^	B^svqWbbVFSjFTgFVF^U{ro_GUqprFxU^{xNibbB	xHgG^GSbbgSZHbbGGip}ohzxNxHZEhxZqUSZ v_Fg{Vbbo}Ly_UqH}	tBg|EIpoG_hVUV^NU|hFyg`{xsr|EszFmpFr{SLFsqxJU	bbbt J^hUrjUE^VbbZgWki^WoW	xW_v]wUTrUqwUFGoyrpi}xJWjrNtZSztV|q^j}HNEmT`H}`FUgrN`IVI	xB_}Ssvz_bbNLjvBHW	yw	h{rp|hSF	 {wp|o_vxbbB{E^is	m`^w]bb``tHWqHxUioJ]bsG_ys|thmS{I|o{bbk``zmI^bbZS`jzUJUyyJ`SrvqSN	qg_y`	Nr`JqhFGL|FIoETrWxxZEbb }bEZ{_vgZWrLzsNBJg{ mE	IvbbyzVHF jUoqypII}NtxGbbtsE}wsj`|xIBZETmsTpzpjWkbb jTizET	]UzJwkZpTpbk^SgSTktbbykxhyNwFjbbZW|L|ZVsL`	jLjiyNoz]Z]rhwbbTzmy|}Z`yJxVzs	m{bvqzhmh|jJ_iFiBvISbbjj}oUxFrBizpLSEvFELZhogy`xL`{pEJzs_JWgWtGB^^}ptFBzIwt}jLEgigEFWjHH^ztpFjhTFSzhWbHt`Tpsps{jp{mth|`kkNkBg}B xGJ|`BxkI{Bry{H{zJ_V|LrsBJ`Z EiNLIo	Tz|tbsbo]Jobb`kUipVBTIg}{	qW^bbBVVsF]kSxTTN|yLjjWyiqrgLt_GwsiJ	VbbrHkIFG|gkgjgv}JVLHwFz`BWxWLIiGL	EjVpmz]vmNTIJ^GSwWhZowJV|	jG{_{IqyFjk{	NZwitz^br}LoqshSBH}jgBHGUEttq^S|j{I{jb	HbbW`mNUG|_}z|^t|oNmh}S{UmjI]pImLps}H``TTEHWqhzWTzhrhssbbjHyV WG|`bbHti_bb_BJm}`rJwoNTw{v|jmWFhI|G{	x}ymhrgI{JEW{EozjjxVWijg|_ZmkgjbESW VSVjNJimVGSV^|`x^bbStbUwGzyo{S	ozvS^^hjWbb}]y{bbsNHx	{sZsWssqBtpq`_j{GyB}JbbGjrWr|kFTygUjho{twwxF Zj_IzqHUqv]ZIrzHohBkvGbbbH_BJGsyLBLoj^TL|NHq_EhkFixU NprIVZHr _BogTxVTx|JJT`j	pBwbbsgkkJVbxymq^ZiHvzgmbb{JgxTohSJt	F|oNGVNoxbbJggWJ yFBiWkVS|rIIbo{z`gbNSEbToB kTmTiz FgBVJz_|gswyxUJZLjmxZTrgxJoqbi^mBsvrz}jSgTNb ssBUZ_{qwhE_T^kGWgL|bjrpbbwgr	txox |Lxm|UksvGqb^s_|ibbm}^hF b}UmxqW`{JygZLm	_VqySrHGIrtp^}TG_Gz`|}rrobb]jZGTIjS|wkpiI_qsrbI`qNxzFSyxV|qZ EEpwtGLNyVr_g^GbNIF tEN{Wwp|J^[[LJLrh]xe]x]b`wbb_EjS^xDwbb|xSS|x`SS|wZ_Ej\x[S\x[X
|x`\SSX`^z|_LL_G`xzN`xzNxzNz|bw|wZ_EjwbEz`Ex`zZ]bz`]xVEj`j_N]b`zjjEVEj^E]y^UxzNwpzEQoor[oexzE`nzwknOOpzEQ}[OO`^wbs]N`^wbs]N`^wbs]N`]N`^`^z|bwex|x`^]b`xjZ]``]bN`^]b`NEzb`]b`EExz``^`xzNUkm^	q]bkEs`^`_xjE_`E]b]es]jbzZ`Ez`Zx Jor}riTvSz|SSSSe Jor}riTvSSb\z_wxExbs]j`P[`POlc\
OlEbcP
OlEbcPOlc\E\b\S]]b]E]Ejwx]wb_LL_G`]b]xb]bN`]b]sz]j`]b]zLJLrh|jSz|S Jor}riTvSSSe|z``|uB]j`z|QOen]xYjwNY`jOfuTsw_jQZwz_|wEefv_]EQzjjQb]uSTsw_jfuTsw_jQCZwz_|wEefibQsEwZQzjjuSTsw_jfuSB]j`z|f|Ezsz]j Jor}riTvSS]bWe|Zj]WB]j`z|EZ^EzwxbwihoriV}viJL oviiL}Z`j]Z`j]^xkwxZ`j]QwSe^xDwkDz|DezimNwLJLrhS
u\x|x`PSwZSPQo}TQPSSPQo}i_LL_GQPSu\x|xQSPQe^xDwkDz|DQPSQSPQo{zbzEzEZsz]jo}Te^xDwkDz|DSo{nGeGeGSzbzEzEZsz]jwZSb\SPQo}TnzDLDIqDecPQPSeP\SPQo}imQPSb\S`xEsz]jE]b`zxwwSPQe^xDwkDz|DS
imnGeGeGS`wzwU`wzwUbwzwEE_ximswULJLrh`|ZwxwxbswULJLrh|z`|`|zHhm`|Zwx`]`|ZwxEz`|Zwxjw``|Zwx^E]`Exz`|ZwxpE]ssz]j`|Zwxj`|ZwxSu\x|xS]S
`PnjzE`PneP\`PYbzZ`xz`G
dcG`PYbzZ`xz`G
dcG`PdYSPeP\PSYSS
bcPbYX
bcPbS]`u\x|xQ`E]b`bwEwx]b_Nws^zEQ Jor}riTv]bpzjLi{zp_LL_GzpxjZ]``]bNEzsz]jzpZSPQLi{}TQPSSPQLi{}iSSPQLi{}TnzDLDIqDecPQPSeP\SPQLi{}imQPSS`Li{oLi}iSQcP]s`Pn`Ps]b`Pn`POlcLi{oLi}iOlc`P`P`PE_Eb`P
EbcPSzbzEzEZsz]jzpj]`N_zE^xD]bj_`SeNjSeNWSeNSeNpS
GeGeGSSeN`N_zEEzx`_`xbw`z_`SZ_Dxj_N]b`Sxj_N]b`Sex|x|wZ_EjhrrJhor JJVTiTv Jor}riTvN_zEN_zExjZ]``]bNN_zEN_zExj]bpzj]SeNZN_zEN_zE`_k`Ew_b`E]`UsE`xzLJLrh_xzwx]wb`xzwss`Nwx]wb\fEzbwZk`k]b|WPSSnE\bSPqDzDscdmqqqKMPSGS_LL_GZZwEj]Z]Dm`Ew_xxE`w^bZ`w^bZ`w^bZzb]s``w^bZ`w^bZ`w^bZzb]s``w^bZ`w^bZ`w^bZ`w^bZZw]s]jNzSw^bw^b`w^bEE`zE]bNwU`zkww`Nb`z`zE`v}V}rrT}bw`z`zkww`^xk|Uwbb]wbbwxz|`z`z_bUbw^bsz]jz_bUbw^bSnSPqDzDscdmqqqKMPS`PSex|xSeNwx]wb`sEEj_xzwx]wbbws]jx_LL_GxejUNejUNejUNxENZz|zjjSkz`twn`PlnLDIzDqDGS[cdmqqqKMl`PSSn\NwYN]bsjzYN_bwZxE``n`POnn\
OcPn\e
OcPPOS`WSWnqDzDsLDBcdMSp	|pwgUxUsm`UkNEW]F]Sn\NwYN]bsjzYN_bwZxE``n`Plnn\
lcPn\e
lcPPlS`lp	|pwgUxUsm`UkNEW]F]NSWnqDzDsLDBcdMSp	|pwgUxUsm`UkNEW]F]lSWnqDzDsLDBcdMSp	|pwgUxUsm`UkNEW]F]QPSS
zDLDIqDecGS}iLJLrh|ZSSPQrh}TzDLDIqDecPQPSSrhj`|pFw|_`iiU`qHxkmW_spEmZNsSSSrhizDsqDcGE\b
bcPSj]NEtEHHk]zzSSPQrh}TnzDLDIqDecGQPSSSSPQii}TnzDLDIqDecGQPSS`Nwx]wb]Z`|z`|_zj```UEbzk_`H	_NWEjzzHEN]`E`|_w^bs_b]wb``U``UwbDDfNwx]wbkj]b`_LL_G`E]`ZHs]j]Z``kjkwEb]Z`Z]``bW`jw^zbzEkzU^E]sz]j]Z`zEZs_jjS|kekzUkzU^E]sz]jE]`kjZ]``^xz|j]Z`]Z``z^E]sz]jxzWx^mWWjg]`sjwzZWwzWm]qZEkm`FZWwzWm]qZEkm`F``jpE]sbwD`wEKQbwDz|JEzNZzbwDz|]`^xEEwE^xEZwEE]pE`xwb`w^xEZwEE]pkwNwx]wb]Z``zbzEbw`zbzE]Z``]Z`kjsz`N]s]b]`|E_`j]`xs]b]`|E_`^xEZwN|wZ_Ej^xDjwN]bex|x_LL_G]Z`]Z`kjE]`kwEb]Z`bW\`[Ez^_EjbwaE[EwjjkzUHqqQ]Z`uCDDy`[zbzEEwjjkzUjwN]bHqqQ]Z`Z]``]Z`]Z`]Z`]Z``jkZwkj]bYjkkj]b]Z``jkZwwUYwx]wb`]Z`]Z``zbzE`zbzE`zbzE`szZrh}Thm{Sn\iYLi{Yo}TnGeGeGS`^xb_Ezj]swE]Nb`U]xQSn\iYLi{Yo}TnGeGeGSSQcPSPQniYLi{Yo}TnzDLDIqDecGQPSeP\SPQm}iQPSQcPE\b\S``S]`s]jn`Pln
lcGl`PSkswE]Nb`U]xQ`Zw^xDwbs]Nex|xS^xDwbs]Nex|x JwETbNE]_LL_GSZxSx|x Jr}JiTv`Zxs]WSs]b`Pn`PlOc JLh}lOcSLi{}TSs]b`Pn`PlOcLJLrhlOc`PK
cP`P`PE\bs]bnQl JLh}lKQE_QE\bSSs]b`Pn`PlOc Ji}VlOc`PK`PE_`PS]Ss]b`Pn`PlOc Ji}VolOc`PK`PE_`PS]Ss]b`Pn`PlOc Ji}ViTJLbblOc`PK`Pszj``PS]SQcPSPQ JwETbNE]QnzDsqDcGQPSeP\SPQ}bD JwETbNE]QmQPSQcPE\b\S`SQcPSPQ JwETbNE]QnzDsqDcGQPSeP\SPQ}bD JwETbNE]QmQPSQcPE\b\S`Skn\b]sYj`kSS
QcP]s`Pn`PC\`Ps]jW]``n`PlSZxSx|xLDIzDqDcGl
bcPbnQcP]s`Pn`Pwaa
bcPb\SZs]b`Pn`PlOcLJLrhlOc`PK
cP`P`PE\bSnSmms]bnQl JLh}lKQE_QE\bSS
QcPs]b`Pn`PlOc Ji}VnoYiTJLbb\lOc`PK
bcPbS]ZSn_xzwx]wb`^Z]N^xs]bnQl JLh}lKQE_QQSPQ QPSE\bS^xEZ^Ez`^wxz|]bpzj]zSlnSZxSx|xLDIzDqDcGlSSwx]wbbzZ`P[`Pln
lcGlSS
`]Ezb`]bn|zj|YszDsqDcGS Jor}riTvNjwkSe`]EswE]Nb`U]xQewssSe`SPSs_b]wb`ex|xii}TrhiSzpzbDz|ex|xSkex|xjwx]wbNWHxt]E_HgqkbqwxgmUsHg^]w`Ej_p`]k	_W|_LL_GZNF	U`HEjjg`kwwUkwwjNzzUwpE`xE`]`EN]`E`|_w^bs_b]wbNwx]wb``E_k```E_k`j]be^xDwkDz|D`xE`]`Zzb]s``]Z]ZSYEnGS``bkUS
nGYnGSSkex|xSs_b]wb`ex|x`]YEYq`xE`]`Zzb]s`xE`]`k]NNwx]wbNwx]wb_E`xb]bN]bpzj]zbwwx]wb`ex|xjEex|xex|xSkex|xSo{GeGeGSu\x|xQSPQe^xDwkDz|DSb\SPQo}TnzDLDIqDecGQPSeP\SPQo}imQPSb\S`S_xjwz`SPSPSS|Z`SPSPex|x]bpzjeNjeN`eNUeNxeNeNZeNpeN`__LL_GeNESeNEPex|xSS Jor}riTvSSSSSe|z``z_wxExbs]j
bcPbuSTsw_jfb\S]^xDwbs]Nex|xSQcPs]b`Pn`PlOc JLh}lOc`PK`PE_`P`P`PSPQ QPSQcPE\b\S]b]NSSz_wxExbs]j`P[ePePbS]Sz_wxExbs]j`Pn\[Y``Pn\On
OEbcGOYln
lEbcGlYn
`OEbcGS]rh]Z`]Z``|sz]j`|z`]b]sz]jwFqtwHxgb`EwbN_zE]bpzj]zSkex|xkkZSPQi}TSPQi}iSSPQi}TnzDLDIqDecPQPSeP\SPQi}imQPSS`ioLi}iSQcP]s`Pn`Ps]b`Pn`POlcioLi}iOlc`P`P`PE_Eb`P
EbcPSikxjZ]``]bNkkzbzEzEZsz]jkNwx]wbS|Z`S`j`|ZxjzSs_b]wb`ex|xN`]wx]wb`|Z`zs_LL_G]`Z_j]`]_xz`]wx]wb`|Z`zsbw`|Zp]EN]bkzzbw`|Zp]EN]bk`]S|pekzUpzb]`|E`wELJLrhSPQrh}TSPQrh}irhex|x|Zxj|ZxjZ]``]bNS
u\x|x`PSEzsz]jsjwUrh]EmkqjwSSSrhizDsqDcGE\b
bcPSrhiSrh}TqDecGQPSSwEx|zbswE]NbSb\QcPSPQrh}T
PcPPSePS`S
QcPSSrhizDsqDcG
bcPE\bn
bcPnE\bY\SZ|ZwEx|zb|ZS
`PbzZ`xz`G
dcG`PdSZb``U]xroJ}rL Trh}ho`EExw`u\|Z]xe]xex|x|`EZxI]xLE|]pS_xjwz`SzbbSZS`]_LL_G`ex|x^xbW`|_jLJLrhwFqtwHxgb|w_Ej`EwbN_zE`N_zE]bEpzjEwb`_x`	mHU_kkEgSeNjex|xEwbN_zEex|xwxNwx]wbex|xEwbE]b``zz`]b`hrrJSmemQtqtQwQBw_b`^_xzwx]wb``^xjz`S
`Pn\nYSPYSSYpzEQYjQYwb`QYs_b]wbQY`jseSS
LDIzDqDGS[EbcGSwbbDrxQzxxj]z]wbSzpz`E]xQ|zE`[_sD	Ep]D wEUEDLjjw^QShrrJSmemQqtQwQwbb`^wbs]NhrrJTBo}LrhhrrJSmemQgqtQwQw]s]}rzNQz|DwbEwjQbwDz|`^x`pE]sSGSYpE]s``Zzb]xEwkYwbbDrxQWSxjz]bz|DwbEwjQbwD`wE}}BLTpE]sxpE]sxEwUjzbwZz]b^gsj_`|zjj^gsj_`|zjj`Nz|xE``x_ENz|_LL_Gj]`xx_ENzjjj]`xx_ENzjj]xz|LJTx_ENzjjEJ_ENz|kEz|sj_`|z|}bzkjEjzEwzjz|jzEwzjz|^xsjzEzjjz|^xsz``z|jz|^xz|jzEz|^xz|jzEz|z_wx]Z]z|jzEzjjz_wx]Z]z|x_ENwb`|zbN^xw]bNzzWv}rv}V}rvJv}V}r]`s]`Ewkw`]``]Zzx`]`_`wZ]xEp]^jZbwEDxEp]^_`wZ]|zbN`__]sjk_]jE````uS`E]xuS`E]xNwx]wb``xE]bbw``xE]b```xE]b`JhJoVrJVrhLi}vBTLwbbDi]`xw`]]wbzz|ZbwbbDrxWS|Zjzxxj]z]wbSW|ZjuSkwfu|Zj``xE]b``wk_`uSkwf``wkv}V}rVvTv}V}rVvT_LL_GSen]xYNYzEYkYxsY`pYWj`W\YwW\Y`jYZxtY]`wn\YS]zz|ZbWS|ZjwbbDbN|wk`zE^xjgjkq	|qW_t`F]ZzkxzNbw^`k]b|W``^jz`_Eju`E]xQzzD`DpzEQ[s_b]wbn|dpzEQE[OOK]swEn][q]u|ejbN|]G[EG[E]bNesEwZ|zEwnxzE`Tbn|e`_k`En]KKmE_EbQEMK`^[bzp]NzwEnO`Ep] wEUEOcKj_[]sn`^`^nONvN]`Ez]wb`Ocne|bns_b]wbnE`dE`eswE}z|ns_b]wbnEdpzEQZ[Cj_]snCZnOz]pOKnO^z]]bNOKnO]b`zjj]bNOceswE}z|ns_b]wbnUd]snEUcaaEUcnO`E]xVvOc[[[j_Z[mM]snZEnO_bEN]`EOcnMMnOz|Ocns_b]wbndMuS`E]xfbwOc]sn`^d`^nONvN]`Ez]wbOcne|bns_b]wbnEdpzEQwU[q]snEnO^z]]bN]b`zjj]bNOc[[[wU[mM]snCwU`^nOEN]`EKd`wxMnOOcns_b]wbndMM_LL_GnOOcns_b]wbndMz}pb]`bEOcnnOOKs_b]wbndpzEQp[nOOc]snpaapedEdb^QB_b]wbnzwknpenMz|nWdMMMEzOce|bns_b]wbnEdEnOOcnOxw```zNOcndOEOMMM`^ENSe`^Zex|xex|xSe`ex|xZ_Dxj_N]b`Nwx]wbSekzxz|xz|wUwxz|]bpzj]zf[`kwwUov}oorrvLJJ}iov}oorrvLJJ}iS
GeGeGSf[`kwwUjzE`zz|ov}oor{}vkbwqwNE]]x`z_b|_NN^p	xNwgHb`EEsNFUjNW_UFWm^`jH`]bE_j`Z^UpNp_sb|qUb|Wjb]bw^zFSeex|xSekex|xews]b]j|UFU^_|bWwtUEHZ^EsZmw||_LL_GjwzDxj_N]b`ex|xzZ]b]b]sUkqpxxw]kbwb^wFxxmkqzZ]b]b]]]w]zkjqHkpxZ`|_w^b^HW^Nw^w^xsZjs]bEwbbwEwx`Wk|WbWUWFNp]t	^xs]jZzbzNEwbbwEwx`js]bEwbbwEwx`s]jZzbzNEwbbwEwx`z_|b]z^UUN|Z^bx	k`^xjwN]bx]|WzNFtgxE_`E_EbbmZ|jZ|E`_`E_E_ztZWgF`p]^`_`E`^U	w`jmwWWxEmk_N]bswEZz]wbbZjbg	HFWm]x`|w^zpzbxj_N]b`UWjw	p	Z	gzZ]b|zDxj_N]b`ex|x`]Ezb`]b_xzxj_N]b`zjjxj_N]b`|xWxqE`zUbbFZN^xzzWZUs]jswjEZzbzNEj|w	x`|ss|sF^xzzWwbbwE^xzzWs`wbbwEj|w	x`|ss|sF^xswwE`]w^qU]tmwUNk^ZxjzE]Eb	x`t]t_|x`z^tjW	WH_Wk	zZ]bswwE`]ZZ|^mtWs	]NjwN]bswwE|^U	xWswEpFE`Wxj_N]b`jwzHks]g]_gz`WjtNg^W_`	_xmbZjpFEbsEkxj_N]b`jwz_LL_Gz	EWqEjExg]mzU	ZkpW|sUkqpxxw]xj_N]b`jwzp]g]bbZbskxZ^s|_ZNU|Us_z_W|wgZxWsg||^|wq|zsE`^]||Zsq]bU	g]t_`^zbsWg	zmmt	kjzEWWZFwHW_]ppNF^wFqtwHxgbZp`|^HW``m_Nt^xkZWW`j`jz`EwpE|U`Ewbs|bpFwHHExE|HEwb`|_j`UwpHt]Hbxpzmmxk_CL[JKLP_eWcCXKP]JWQPXYTW[WWPHJQ_WE[[	JPLV]YaUFaUWWX|mnjvM]aH[LQ
NRKYWP\_SirkywpzlsUZVJIbbOX}q{FGhxubD 	fgdoTEeCcB`t^JLJrh`pEwteHgxj_N]bkzZ VTivSDU|^u\so}WQP[{nGBylKqfamF	bbIdOMcCY
XRLXQLTTMJLR[P[TENMJLNQMJ[eTcLNX_RM[[eTcXeNcCL[JKLPLCXKP]JWQPSF]
TFJDWEL[JKLPXYTW[WWPHJQ_WCXKP]JWQPRYN[aTSQUDQ
WETWPJWL[JKLPXYTW[WWPHJQ_TCXKP]JWQPD	]I_DOGWETWL[JKLPXYTW[WWPHJQ_TCXKP]JWQP_UMYGNJ\WETWL[JKLPXYTW[WWPHJQ_TCXKP]JWQPIQ[
HR_WETWPJWL[JKLPXYTW[WWPHJQ_TCyrq|rmeaaM]Xa[KDO
YMUaR\VacSF]
TFJDyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
yrq|rmeaaM]Xa_K_QN_\W	a]a	c_UMYGNJ\	yrq|rmeaaM]XaHF	ULKWWW]ZacRYN[aTSQUDQ
yrq|rmeaaM]Xa[NP\	U	ac_UMYGNJ\yrq|rmeaaM]XaNJ]SSODDIGGaac_UMYGNJ\yrq|rmeaaM]Xa]FMXaRDGSQacD	]I_DOGyrq|rmeaaM]XaNGLV\SLPGacRYN[aTSQUDQ
yrq|rmeaaM]XaYUFJ]NNDacXYTW[WWPHJQ_yrq|rmeaaM]Xa]]MPGGSWaX]TacD	]I_DOGyrq|rmeaaM]XaYR\Y]GUO[a	cRYN[aTSQUDQ
	yrq|rmeaaM]XaJSJX
DZZNIIJac_UMYGNJ\yrq|rmeaaM]XaYVI_UURR
OPac_UMYGNJ\yrq|rmeaaM]XaZ
RaK\acSF]
TFJDyrq|rmeaaM]XaI	WS[XMPacRYN[aTSQUDQ
yrq|rmeaaM]XaPWQFKO
D
LacD	]I_DOGyrq|rmeaaM]Xa]HYHVUa
c_UMYGNJ\
yrq|rmeaaM]XaOG\FSVKacXYTW[WWPHJQ_yrq|rmeaaM]XaGaWRR]U__[acXYTW[WWPHJQ_yrq|rmeaaM]XaNIR	Ta	acXYTW[WWPHJQ_yrq|rmeaaM]XaIMI

\G\\a
cIQ[
HR_
yrq|rmeaaM]XaS

	ZLD	a
cXYTW[WWPHJQ_
yrq|rmeaaM]XaIWMLWJDNRDPa
cXYTW[WWPHJQ_
yrq|rmeaaM]XaXMMOZPIRa
cD	]I_DOG
yrq|rmeaaM]XaURRZW
ITGa
cXYTW[WWPHJQ_
yrq|rmeaaM]XaK_T]FKQRPS[KacIQ[
HR_yrq|rmeaaM]XaaQKLGJP]_OIacSF]
TFJDyrq|rmeaaM]XaJFVY[	SJPKa	cXYTW[WWPHJQ_	yrq|rmeaaM]Xa\TOUSOOMFG\a	cSF]
TFJD	yrq|rmeaaM]XaKHLOSPVW]RWJa	cIQ[
HR_	yrq|rmeaaM]XaR
[HRNLSDPHa	
cXYTW[WWPHJQ_	
yrq|rmeaaM]XaSF
YSF[LIJ
Ta	cD	]I_DOG	yrq|rmeaaM]Xa]QU\]aRRa	cIQ[
HR_	yrq|rmeaaM]XaFHHDS]ZRTNa	cIQ[
HR_	yrq|rmeaaM]XaHSO\NMa_Da
cD	]I_DOG
yrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
yrq|rmeaaM]Xa_GRUDISIa	cD	]I_DOG	yrq|rmeaaM]XaNDD_U_S]R\\acXYTW[WWPHJQ_yrq|rmeaaM]XaRJLRacD	]I_DOGyrq|rmeaaM]XaFOMVMVNG[KNacRYN[aTSQUDQ
yrq|rmeaaM]Xa[PD\GWFacSF]
TFJDyrq|rmeaaM]XaZLWL
M]XJPacD	]I_DOGyrq|rmeaaM]Xa__VX_]O[ac_UMYGNJ\yrq|rmeaaM]XaY	OD_MOOKGPa
	c_UMYGNJ\
	yrq|rmeaaM]XaUYGQMULaFLa
cSF]
TFJD
yrq|rmeaaM]Xa_LHMQPFPD
Ma
cD	]I_DOG
yrq|rmeaaM]XaaVYPVSS
acD	]I_DOGyrq|rmeaaM]XaRSVOIDaFHTJacSF]
TFJDyrq|rmeaaM]XaKQTGQ
Na	cRYN[aTSQUDQ
	yrq|rmeaaM]XaD]SGTYaFPQHDacD	]I_DOGyrq|rmeaaM]XaUM_SDP\\\a
cD	]I_DOG
yrq|rmeaaM]XaQVIZMF
UWMPacIQ[
HR_yrq|rmeaaM]XaaD_[
OPQ\JDLa	cD	]I_DOG	yrq|rmeaaM]XaGZSMV_XPGQNacIQ[
HR_yrq|rmeaaM]XaO	SDSSQ]YRLacRYN[aTSQUDQ
yrq|rmeaaM]XaOP\[VSWFHacSF]
TFJDyrq|rmeaaM]Xa_ZISTM[HKJa
cSF]
TFJD
yrq|rmeaaM]Xa\[X\\K[PFa
c_UMYGNJ\
yrq|rmeaaM]XaV
\PIPNJK	Ra
cD	]I_DOG
yrq|rmeaaM]XaXSZRITaGaOLa	cIQ[
HR_	yrq|rmeaaM]XaHH\P]DGF_MRMQa	cXYTW[WWPHJQ_	yrq|rmeaaM]XaQXZTaR[L
VQOa		cD	]I_DOG		yrq|rmeaaM]XaZY_R
WNVSINacXYTW[WWPHJQ_yrq|rmeaaM]Xa[PS[FRLVacSF]
TFJDyrq|rmeaaM]Xa]XUTDWTUacIQ[
HR_yrq|rmeaaM]XaZRTJRVaacD	]I_DOGyrq|rmeaaM]XaU	ZI\J
[D_ac_UMYGNJ\yrq|rmeaaM]XaUQHVIIDGacRYN[aTSQUDQ
yrq|rmeaaM]Xa\aLGRF
acIQ[
HR_yrq|rmeaaM]XaI	NPMOO
Qac_UMYGNJ\yrq|rmeaaM]XaSIWa]PST[acRYN[aTSQUDQ
yrq|rmeaaM]XaN]RPUKT\ac_UMYGNJ\yrq|rmeaaM]XaJ_JJHSOXWYacIQ[
HR_yrq|rmeaaM]XaLQG\RONGGRXWacD	]I_DOGyrq|rmeaaM]XaVMQGFWM]ac_UMYGNJ\yrq|rmeaaM]Xa]FQGV	\SacIQ[
HR_yrq|rmeaaM]Xa[QXFPSWILaQacD	]I_DOGyrq|rmeaaM]XaV[RJJX\MN
acD	]I_DOGyrq|rmeaaM]XaXRMONPW[a	cXYTW[WWPHJQ_	yrq|rmeaaM]XaZ
ZVRO
UNLDKa
cRYN[aTSQUDQ

yrq|rmeaaM]XaYQMWZU	ZQPacXYTW[WWPHJQ_yrq|rmeaaM]XaS]ZINNJ_ac_UMYGNJ\yrq|rmeaaM]XaFL_RINU
a
cRYN[aTSQUDQ

yrq|rmeaaM]Xa\	V]W	QFacRYN[aTSQUDQ
yrq|rmeaaM]Xa]HN[Q	\\KPOVacRYN[aTSQUDQ
yrq|rmeaaM]XaKODUaRWJ]
acIQ[
HR_yrq|rmeaaM]XaXUWXXXT
OYacIQ[
HR_yrq|rmeaaM]XaS_QNWZRIWG[a	c_UMYGNJ\	yrq|rmeaaM]XaZOVZW
]WRZLLKa	cSF]
TFJD	yrq|rmeaaM]XaPT[N\H_\U	LXacD	]I_DOGyrq|rmeaaM]XaTWRSTN
\YG
\a
cXYTW[WWPHJQ_
yrq|rmeaaM]XaMHSN\]HKXIacIQ[
HR_yrq|rmeaaM]XaVTN_HLNZS_Na
cSF]
TFJD
yrq|rmeaaM]XaUKVQJ]YK\a
cRYN[aTSQUDQ

yrq|rmeaaM]XaM_[SORX\[Va
cXYTW[WWPHJQ_
yrq|rmeaaM]XaX	UM	IQQaVa
cRYN[aTSQUDQ

yrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ

yrq|rmeaaM]XaWFGGDF

Ma
	cXYTW[WWPHJQ_
	yrq|rmeaaM]XaZSHITKKZFa
	cXYTW[WWPHJQ_
	yrq|rmeaaM]Xa[	aQ\_KWK[Xa
cD	]I_DOG
yrq|rmeaaM]XaaJVVW]M\acSF]
TFJDyrq|rmeaaM]XaZGO[QZ	Za	cXYTW[WWPHJQ_	yrq|rmeaaM]XaZNPRLPO\YVYacSF]
TFJDyrq|rmeaaM]XaWTW	TG[Mac_UMYGNJ\yrq|rmeaaM]Xa_\XLLLPacXYTW[WWPHJQ_yrq|rmeaaM]XaZUTOXXQaQac_UMYGNJ\yrq|rmeaaM]XaVWRNOHYa]Oa	cXYTW[WWPHJQ_	yrq|rmeaaM]XaJLJKYO[UZQLDa	c_UMYGNJ\	yrq|rmeaaM]XaW_	L\NQ_
Va	cRYN[aTSQUDQ
	yrq|rmeaaM]XaLYIZQQ_TacRYN[aTSQUDQ
yrq|rmeaaM]Xa]LQPPTVVaJa
cSF]
TFJD
yrq|rmeaaM]XaORNGZZMPa
cD	]I_DOG
yrq|rmeaaM]XaD\JONRDH[acXYTW[WWPHJQ_yrq|rmeaaM]XaUUN]FI]N
Ia
cD	]I_DOG
yrq|rmeaaM]XaNWFKW[T\a	cIQ[
HR_	yrq|rmeaaM]XaIFKVP
MTUFUacXYTW[WWPHJQ_yrq|rmeaaM]XaXKPX_GDYIMa	c_UMYGNJ\	yrq|rmeaaM]XaPP_MVXQR[a	
cSF]
TFJD	
yrq|rmeaaM]XaHMU
XNXMKa		cXYTW[WWPHJQ_		yrq|rmeaaM]XaDFQaWHVacD	]I_DOGyrq|rmeaaM]Xa]	PLD	
Xac_UMYGNJ\yrq|rmeaaM]Xa_NQ
LUMaaOVacIQ[
HR_yrq|rmeaaM]Xa]S[MMZT
acD	]I_DOGyrq|rmeaaM]XaUTQXHGKL\Ka
c_UMYGNJ\
yrq|rmeaaM]XaJZ_MYLKaLa	cD	]I_DOG	yrq|rmeaaM]XaUaHYNJDK\a	cSF]
TFJD	yrq|rmeaaM]XaVWWSWO[Z\acIQ[
HR_yrq|rmeaaM]XaG_YaDRUXUNa
	cRYN[aTSQUDQ

	yrq|rmeaaM]XaOLaK	NN	acD	]I_DOGyrq|rmeaaM]XaVRFQ]YMYDD]a

cRYN[aTSQUDQ


yrq|rmeaaM]XaXJ	S]
XXOa
	cD	]I_DOG
	yrq|rmeaaM]XaHGUUYZFXR	NIac_UMYGNJ\yrq|rmeaaM]XaIOLQOWZKGNaDa		cXYTW[WWPHJQ_		yrq|rmeaaM]Xa]_HN]GJHLOFRa	
	cRYN[aTSQUDQ
	
	yrq|rmeaaM]XaDXH_IGJa
cIQ[
HR_
44444444Z[XWP[ZD	]I_DOGQL[FWJ44XKP]JWQPRINYW\WDWV_QNR
I	4E4444L[JKLPWMM[Jyrq|rmeD	]I_DOGcyrq|rmeSF]
TFJDcXYTW[WWPHJQ_444C44XKP]JWQPXTDWYLRT_NPTYMLP4E4L[JKLPaaxwr{aa4C4XKP]JWQPVKYYDIHNYQPMT4444E444L[JKLPyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4C4XKP]JWQPQFSXaFSW[	_4E4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGL[JKLPNRKYWPa\_M[P_S[XTDWYLRT_NPTYMLP4J]YVRPQ[aXTDWYLRT_NPTYMLP4YOW\[Y
OUZXZ[XWP[ZSF]
TFJDinanrkywpazwl4WXYOW\[Y
OUZXyrq|rmeaaM]Xa_K_QN_\W	a]a	cJ]YVRPQ[aYOW\[Y
OUZXL[JKLPyrq|rmeaaM]XaHF	ULKWWW]Zacyrq|rmeaaM]Xa[NP\	U	acJ]YVRPQ[ayrq|rmeaaM]XaNJ]SSODDIGGaacYOW\[Y
OUZX4L[JKLPyrq|rmeaaM]Xa[KDO
YMUaR\Vacyrq|rmeaaM]Xa]FMXaRDGSQacJ]YVRPQ[ayrq|rmeaaM]Xa[KDO
YMUaR\VacJ]YVRPQ[a44C4XKP]JWQP\PQQYLWZWNM]_KP4E4444L[JKLPyrq|rmeaaM]XaNGLV\SLPGacZ[XWP[ZD	]I_DOGinskanrkywpazwlina}qpj{pjazwl_UMYGNJ\
44C4XKP]JWQP]	\O_VSMFRGQL_DI4E4L[JKLPyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP4C4XKP]JWQPMO]\DJR_OJ
	ZVVPKSZ
H	MT
H]IFHJ	W_M
WGIQa[KKMIX_RM[4E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_~yrq|rmeaaM]XaYUFJ]NNDacKSZ
H	MT
H]IFHJ	W_MWGIQa[KKMIX_RM[4C4444XKP]JWQPY_HVRRKFFH]X
]VL
RF_aLRUKPPPL[]IFHJ	W_M4E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~yrq|rmeaaM]Xa]]MPGGSWaX]TacF_aLRUKPPPL[]IFHJ	W_MX_RM[444C4XKP]JWQP_I	Q]G
P
F_aLRUKPPPL[4E4444L[JKLPyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	~yrq|rmeaaM]XaYR\Y]GUO[a	cF_aLRUKPPPL[X_RM[4C4XKP]JWQPY[D\QVWZZP_NIZPaYMYD_D4E4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DL[JKLPJLK[44Y_HVRRKFFH]X
]VL
RNIZPaYMYD_D

4WX_I	Q]G
P
NIZPaYMYD_DE4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~QN]_]V[aWPH_RWZ_J[NIZPaYMYD_DJLK[4L[JKLPJLK[4C4Y_HVRRKFFH]X
]VL
Ryrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D
	
4WX_I	Q]G
P
NIZPaYMYD_DE4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~QN]_]V[aWPH_RWZ_J[NIZPaYMYD_DJLK[4444L[JKLPJLK[4C4DU[L[YMZaMYFW~yrq|rmeaaM]XaYVI_UURR
OPacNIZPaYMYD_DSF]
TFJD4WXDU[L[YMZaMYFWE4~yrq|rmeaaM]XaZ
RaK\acDU[L[YMZaMYFWNVNbP4~X]RQM[DU[L[YMZaMYFW4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~QN]_]V[aWPH_RWZ_J[NIZPaYMYD_DJLK[44L[JKLPJLK[4C4L[JKLPX_RM[444C444XKP]JWQPLODXSO\LJYYK	YKVIVPZNIZPaYMYD_D4E4LNIUZJSGOaZyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D4TPLV]LY\OQyrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_DRYN[aTSQUDQ
4XQL[_]V_LL_GXYTW[WWPHJQ_
XYTW[WWPHJQ_RYN[aTSQUDQ
IQ[
HR_	_M[U
WYDTNTSE4YH_OPKN\_O_TLNIUZJSGOaZ[U
WYDTNTSTPLV]LY\OQ4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacYH_OPKN\_O_TY[D\QVWZZP_YH_OPKN\_O_T4C4SPMIYDMP_LNIUZJSGOaZTPLV]LY\OQRYN[aTSQUDQ
444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacSPMIYDMP_Y[D\QVWZZP_SPMIYDMP_4WXZ[XWP[ZIQ[
HR_E4VaTUa_YPZina}qpj{pjazwlXYTW[WWPHJQ_TPLV]LY\OQ4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacVaTUa_YPZY[D\QVWZZP_VaTUa_YPZ4C4aNZZ[XWP[Z_UMYGNJ\~yrq|rmeaaM]XaI	WS[XMPacinanrkywpazwlX_RM[4444WWXHUUPXXR~yrq|rmeaaM]XaI	WS[XMPacLNIUZJSGOaZ4444WXaNZWWXHUUPXXRyrq|rmeaaM]Xa]FMXaRDGSQacWWXHUUPXXRaNZE4]D	aN	_J
TLF~yrq|rmeaaM]XaPWQFKO
D
LacWWXHUUPXXR4WXyrq|rmeaaM]Xa]HYHVUa
c]D	aN	_J
TLFyrq|rmeaaM]XaOG\FSVKac]D	aN	_J
TLF~yrq|rmeaaM]XaGaWRR]U__[acWWXHUUPXXR4C44C4XKP]JWQPQIRG	HYHaSFaX]]4E4MJ_JW]aRMOIMLKF444WXaRMOIMLKFL[JKLPaRMOIMLK4aRMOIMLKPKRR44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	E[MZL
RLIF]WU~NQMWFaY[J[KWZWXyrq|rmeaaM]XaNIR	Ta	ac[MZL
RLIF]WUaRMOIMLK[MZL
RLIF]WUC4WXaRMOIMLKPKRRE44QIQKFOXaHSPGWN[P	
XIISPKKOPMXO	]LQRYN[aTSQUDQ
4444WXyrq|rmeaaM]XaIMI

\G\\a
cQIQKFOXaHEQ[XXS
U~XWR[QIP[LQIQKFOXaH_I	Q]G
P
QIQKFOXaHWXyrq|rmeaaM]XaNIR	Ta	acQ[XXS
UaRMOIMLKQ[XXS
UC4C4L[JKLPaRMOIMLK4C4XKP]JWQP\N[QQHQ_PKUMKMZFNXLaR
WNWJSW4E4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cyrq|rmeaaM]Xa[KDO
YMUaR\VacZFNXLaR
WNWJSWIQ[
HR_
L[JKLP4WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWBB~yrq|rmeaaM]XaIWMLWJDNRDPa
cZFNXLaR
WNWJSWL[JKLP44aP[NS]Q~yrq|rmeaaM]XaPWQFKO
D
LacZFNXLaR
WNWJSW4WXyrq|rmeaaM]Xa]HYHVUa
caP[NS]QXQL[_]VaP[NS]Q_MQ	MNQOPFDE4WXQ	MNQOPFDBBQ	MNQOPFDSF]
TFJD

]QPJWPK[4444F_aLRUKPPPL[ZFNXLaR
WNWJSWQ	MNQOPFD4WX~yrq|rmeaaM]XaS

	ZLD	a
cF_aLRUKPPPL[~yrq|rmeaaM]XaIWMLWJDNRDPa
cF_aLRUKPPPL[\N[QQHQ_PKUMKMF_aLRUKPPPL[[RM[_I	Q]G
P
F_aLRUKPPPL[4C4~yrq|rmeaaM]XaGaWRR]U__[acZFNXLaR
WNWJSW4C4XKP]JWQPOT[]JYLaVIJO[XaQDFYTWXWLUUPHNaJJ\R_4E4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cXaQDFYTWL[JKLPX_RM[4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXaQDFYTWE4WX~yrq|rmeaaM]XaXMMOZPIRa
cXaQDFYTWL[JKLPX_RM[4L[JKLPVHSVZMU[ZW\LY_QMUMXaQDFYTWXWLUUPHNaJJ\R_JLK[X_RM[4444C4WX~yrq|rmeaaM]XaS

	ZLD	a
cXaQDFYTWE4WX~yrq|rmeaaM]XaS

	ZLD	a
cXWLUUPHNaJJ\R_MO]\DJR_OJ
	ZVVPXWLUUPHNaJJ\R_
JLK[L[JKLPX_RM[4aP[NS]Q~yrq|rmeaaM]XaPWQFKO
D
LacXaQDFYTW4WXyrq|rmeaaM]Xa]HYHVUa
caP[NS]QL[JKLPX_RM[4XQL[_]VaP[NS]Q_MQ	MNQOPFDE4WXQ	MNQOPFDBBQ	MNQOPFDSF]
TFJD

]QPJWPK[444WXOT[]JYLaVIJO[XaQDFYTWQ	MNQOPFDXWLUUPHNaJJ\R_Q	MNQOPFDL[JKLPX_RM[4444C4L[JKLPJLK[4C4L[JKLPJLK[4C4XKP]JWQPMQ\WLYZaV
PWT	KHUZNIZPaYMYD_D4E4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DL[JKLPX_RM[44WX~yrq|rmeaaM]XaURRZW
ITGa
cNIZPaYMYD_DL[JKLPX_RM[4WX~yrq|rmeaaM]XaURRZW
ITGa
cyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_DL[JKLPX_RM[44L[JKLPJLK[4C4XKP]JWQPIHPXVXNL_VN\MGYaMNIZPaYMYD_D4E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ

	yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4C4XKP]JWQP[TSM]VFID	aQPDYY\H	HLM[Y_JFI4E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
BByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

L[JKLPX_RM[44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDY[JaJL_PMW[PJD	]I_DOGL[JKLPX_RM[4U
WYFXH\RL~yrq|rmeaaM]XaI	WS[XMPac\PQQYLWZWNM]_KP4WXU
WYFXH\RLX_RM[BB~yrq|rmeaaM]XaS

	ZLD	a
cU
WYFXH\RLL[JKLPX_RM[4OU
M_LX
QPKRR4444WXYY\H	HLM[Y_JFIPKRRE4OU
M_LX
Q~yrq|rmeaaM]XaI	WS[XMPacYY\H	HLM[Y_JFI44WXOU
M_LX
QX_RM[BByrq|rmeaaM]Xa]FMXaRDGSQacOU
M_LX
QU
WYFXH\RLL[JKLPX_RM[444C4]NT]PKKyrq|rmeaaM]Xa]FMXaRDGSQacU
WYFXH\RL4444WX~yrq|rmeaaM]XaS

	ZLD	a
c]NT]PKKBB~yrq|rmeaaM]XaURRZW
ITGa
c]NT]PKKL[JKLPX_RM[4WX[]SUDZNOTUPU
WYFXH\RLBB[]SUDZNOTUP]NT]PKKL[JKLPX_RM[4ILG	OaPXLZ~XWR[N[LSM]NT]PKK444WXILG	OaPXLZX_RM[ILG	OaPXLZ	
E4ZORHO\NIQIRG	HYHaSFaX]]4WXZORHO\NIPKRRBB~XWR[QIP[L]NT]PKKZORHO\NI~XWR[QIP[LU
WYFXH\RLZORHO\NIL[JKLPX_RM[4C4]	VZXSP
G~yrq|rmeaaM]XaK_T]FKQRPS[Kac]NT]PKKLDTDJN[DG\	FT~yrq|rmeaaM]XaK_T]FKQRPS[KacU
WYFXH\RL4WXyrq|rmeaaM]Xa]HYHVUa
c]	VZXSP
Gyrq|rmeaaM]Xa]HYHVUa
cLDTDJN[DG\	FTWMM[J]	VZXSP
GeIQ[
HR_cWMM[JLDTDJN[DG\	FTeRYN[aTSQUDQ
c]	VZXSP
GeSF]
TFJD
cLDTDJN[DG\	FTeRYN[aTSQUDQ

cL[JKLPX_RM[4aP[NS]Q~yrq|rmeaaM]XaPWQFKO
D
LacU
WYFXH\RL4WXyrq|rmeaaM]Xa]HYHVUa
caP[NS]QL[JKLPX_RM[4OVJIDUJNGWT\_LL_G4XQL[_]VaP[NS]Q_MQ	MNQOPFDE4WXQ	MNQOPFDBBQ	MNQOPFDIQ[
HR_

]QPJWPK[4F_aLRUKPPPL[U
WYFXH\RLQ	MNQOPFD4444HDVDUaaO
HO~yrq|rmeaaM]XaI	WS[XMPacF_aLRUKPPPL[4WXOU
M_LX
QPKRRHDVDUaaO
HOX_RM[HDVDUaaO
HOOU
M_LX
Q]QPJWPK[44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[aKIGURZU\I_P
SaFF_aLRUKPPPL[]QPJWPK[4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cF_aLRUKPPPL[BB~yrq|rmeaaM]XaXMMOZPIRa
cF_aLRUKPPPL[L[JKLPX_RM[4OVJIDUJNGWT\ecQ	MNQOPFD44C4ZVHXJFNWGGFKaQyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacKPWOWZJLK[FF4NGW_D	W[XG]NT]PKKRYN[aTSQUDQ
ZVHXJFNWGGFKaQ4KMP
Xa]VV]NT]PKKSF]
TFJD	ZVHXJFNWGGFKaQ4444WXMO]\DJR_OJ
	ZVVPNGW_D	W[XG	JLK[L[JKLPX_RM[4XQL[_]VOVJIDUJNGWT\_MQ	MNQOPFDE4WXOT[]JYLaVIJO[U
WYFXH\RLQ	MNQOPFDNGW_D	W[XGQ	MNQOPFDE\N[QQHQ_PKUMKMNGW_D	W[XGL[JKLPX_RM[C4C4WXWWODUHSXYW_HaU
WYFXH\RLKMP
Xa]VVE\N[QQHQ_PKUMKMNGW_D	W[XGL[JKLPX_RM[C4WXWWODUHSXYW_HaNGW_D	W[XGU
WYFXH\RLEWWODUHSXYW_HaKMP
Xa]VVU
WYFXH\RL\N[QQHQ_PKUMKMNGW_D	W[XGL[JKLPX_RM[C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_~]R[_LMJ_J]_]V[JLK[4WXOU
M_LX
QPKRRyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~QN]_]V[aWPH_RWZ_J[OU
M_LX
QJLK[4444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~M[JaJL_PMW[PJXYTW[WWPHJQ_	4444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~Z[R[J[aJL_PMW[PJSF]
TFJD44QWVIDDHOPHQ[VKZMSF]
TFJDXYTW[WWPHJQ_
YY\H	HLM[Y_JFIPKRRyrq|rmeaaM]Xa[KDO
YMUaR\VacYY\H	HLM[Y_JFI_UMYGNJ\4L[JKLPJLK[4C4XKP]JWQPG	Ha	a]S_	GX	SF_U
D[N	FYQMQY4E4444JLGE444WX_U
D[N	FYQMQYWPMJ_P][QX}RQMKL[EWGIQa[KKMIP[Il[XR[]JWQPxKP]JWQP_U
D[N	FYQMQYL[JKLPWGIQa[KKMI Y[JxWR[p_S[C444WXyrq|rmeaaM]XaIMI

\G\\a
c_U
D[N	FYQMQYyrq|rmeaaM]Xa_K_QN_\W	a]a	c_U
D[N	FYQMQY_UMYGNJ\X_RM[EWGIQa[KKMIP[Il[XR[]JWQPs[JVQZ_U
D[N	FYQMQYL[JKLPWGIQa[KKMI Y[JxWR[p_S[C4WXyrq|rmeaaM]XaIMI

\G\\a
c_U
D[N	FYQMQYyrq|rmeaaM]XaIVPaITaGa
c_U
D[N	FYQMQYEWGIQa[KKMIP[Il[XR[]JWQPxKP]JWQP_U
D[N	FYQMQYL[JKLPWGIQa[KKMI Y[JxWR[p_S[C4WXyrq|rmeaaM]Xa]HYHVUa
c_U
D[N	FYQMQYyrq|rmeaaM]XaOG\FSVKac_U
D[N	FYQMQYEWGIQa[KKMIP[Il[XR[]JWQPs[JVQZ_U
D[N	FYQMQYec_U
D[N	FYQMQYecL[JKLPWGIQa[KKMI Y[JxWR[p_S[C4C]_J]VjVLQI_\R[Q	MNQOPFDEC]_J]V{F][NJWQPQ	MNQOPFDEC4L[JKLPPKRR4C4XKP]JWQPUZJ	FJLQQFQ	_O
	K[UNIZPaYMYD_D4E44YRQ\_RPIJG
JIOZ\4WXyrq|rmeaaM]Xa]HYHVUa
cPIJG
JIOZ\L[JKLP444RaYLaVQFGaZ~yrq|rmeaaM]XaI	WS[XMPacNIZPaYMYD_D4WXRaYLaVQFGaZX_RM[RaYLaVQFGaZNIZPaYMYD_D4XIPX
HNRVRSI	~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4XQL[_]VPIJG
JIOZ\_MLKDR	MVMLQJ FaKPROMG_NE4WXyrq|rmeaaM]XaJFVY[	SJPKa	cFaKPROMG_NWMM[JFaKPROMG_N ]_RR\_]UMyrq|rmeaaM]Xa]HYHVUa
cFaKPROMG_N ]_RR\_]UMGKO[TN_MJFaKPROMG_N ]_RR\_]UM4[RM[WXyrq|rmeaaM]Xa]HYHVUa
cFaKPROMG_NGKO[TN_MJFaKPROMG_N4[RM[]QPJWPK[444XQL[_]VGKO[TN_MJ_M\X
S
_]aG\Za RWMJE4XQL[_]V_LL_GRWMJ_MDJ
YT\	NFJ[H
E4444_U
D[N	FYQMQYWMM[JDJ
YT\	NFJ[H
eD	]I_DOGcDJ
YT\	NFJ[H
eD	]I_DOGcPKRR4WX_U
D[N	FYQMQYPKRR]QPJWPK[4J]YVRPQ[aG	Ha	a]S_	GX	SF_U
D[N	FYQMQY4WXyrq|rmeaaM]XaIMI

\G\\a
cJ]YVRPQ[a]QPJWPK[4]RJTZLT\X~yrq|rmeaaM]XaI	WS[XMPacJ]YVRPQ[a4WX]RJTZLT\XX_RM[]RJTZLT\XRaYLaVQFGaZBBJ]YVRPQ[aNIZPaYMYD_D]QPJWPK[4WXXIPX
HNRVRSI	X_RM[]RJTZLT\XXIPX
HNRVRSI	]QPJWPK[4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~L[SQH[aXWRJ[LLKDR	MVMLQJ_U
D[N	FYQMQY\X
S
_]aG\Za4C4C4C4444C4XKP]JWQP_IT
RFFK[aFG\[4E44HXG_NW]N	\PQQYLWZWNM]_KP4WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	L[JKLP4PORUXFG_G
Iyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~yrq|rmeaaM]Xa\TOUSOOMFG\a	cHXG_NW]N	D	]I_DOG	X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cPORUXFG_G
IL[JKLP4XIPX
HNRVRSI	~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4XQL[_]VPORUXFG_G
I_MJ]YVRPQ[aE4]RJTZLT\X~yrq|rmeaaM]XaI	WS[XMPacJ]YVRPQ[a44WXXIPX
HNRVRSI	X_RM[]RJTZLT\XXIPX
HNRVRSI	]QPJWPK[4WXaKIGURZU\I_P
SaFJ]YVRPQ[a

]QPJWPK[4[MZL
RLIF]WURGV	JVOR]WJ]YVRPQ[a4M\UN_MUZNVU[MZL
RLIF]WUPKRRBBH[LMWQPa]QSN_L[[MZL
RLIF]WURINYW\WDWV_QNR
I	4WXM\UN_MUZNVUBBMQ\WLYZaV
PWT	KHUZJ]YVRPQ[aUZJ	FJLQQFQ	_O
	K[UJ]YVRPQ[a444C4C44XKP]JWQPGTOMLTaWMG
IQPG
F_aLRUKPPPL[QIQKFOXaH44E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~yrq|rmeaaM]XaKHLOSPVW]RWJa	cF_aLRUKPPPL[QIQKFOXaHX_RM[444C4XKP]JWQPI_HUSY[\MMDZQUHF_aLRUKPPPL[444E4KPZMJFF[aVZQYIVUTIDP[XTYXJ4L[JKLPGTOMLTaWMG
IQPG
F_aLRUKPPPL[KPZMJFF[aVKPZMJFF[aV	
	
TJ_	QLHU	YJSMDSOF4C4XKP]JWQPWWODUHSXYW_HaD
O
XHPRMU[FaK]JNV_HK4E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
~yrq|rmeaaM]XaR
[HRNLSDPHa	
cD
O
XHPRMU[FaK]JNV_HKX_RM[4C4XKP]JWQPVHSVZMU[ZW\LY_QMUMD
O
XHPRMU[FaK]JNV_HK4E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	~yrq|rmeaaM]XaSF
YSF[LIJ
Ta	cD
O
XHPRMU[FaK]JNV_HKX_RM[4C4XKP]JWQPSPGWN[P	
XIISPKKSZ
H	MT
HF_aLRUKPPPL[4444E4L[JKLPyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~yrq|rmeaaM]Xa]QU\]aRRa	cKSZ
H	MT
HF_aLRUKPPPL[X_RM[4C4XKP]JWQPYU[X]PK	S
[4E4MJ_JW]MPGO	FQPKRR4WXMPGO	FQPKRRL[JKLPMPGO	FQ4MPGO	FQyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
		yrq|rmeaaM]XaFHHDS]ZRTNa	c_UMYGNJ\	4WX~yrq|rmeaaM]XaS

	ZLD	a
cMPGO	FQ~yrq|rmeaaM]XaURRZW
ITGa
cMPGO	FQL[JKLPMPGO	FQ4DODNOF_PN[NTPVHZ[XWP[ZIQ[
HR_ina}qpj{pjazwlZ[XWP[ZSF]
TFJD|mnjvRYN[aTSQUDQ
44WXDODNOF_PN[NTPVHE4J]YVRPQ[ayrq|rmeaaM]XaNGLV\SLPGacDODNOF_PN[NTPVHXYTW[WWPHJQ_IQ[
HR_4WX~yrq|rmeaaM]XaS

	ZLD	a
cJ]YVRPQ[a~yrq|rmeaaM]XaYUFJ]NNDacJ]YVRPQ[a
	JLK[4444WX~yrq|rmeaaM]XaS

	ZLD	a
cJ]YVRPQ[a~yrq|rmeaaM]XaURRZW
ITGa
cJ]YVRPQ[aE4444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~NKJ[PHXYTW[WWPHJQ_
J]YVRPQ[a4yrq|rme_UMYGNJ\c4MPGO	FQJ]YVRPQ[a4C4C4L[JKLPMPGO	FQ4C4XKP]JWQPOWSW[YWPZ	XJM4444E4KSZ
H	MT
H]	\O_VSMFRGQL_DI4]IFHJ	W_M\PQQYLWZWNM]_KP4WXKSZ
H	MT
H]IFHJ	W_ML[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4\VWWLWIU\MD~yrq|rmeaaM]XaI	WS[XMPacKSZ
H	MT
H4Q[F_Y\MM]IXT[V~yrq|rmeaaM]XaI	WS[XMPac]IFHJ	W_M4L[JKLP\VWWLWIU\MDX_RM[Q[F_Y\MM]IXT[VX_RM[\VWWLWIU\MDQ[F_Y\MM]IXT[V44C4L[JKLPX_RM[4C444XKP]JWQPTJ_	QLHU	YJSMDSOF444E4L[JKLP
4C4XKP]JWQPLRXUaZV_DZYG	4444E4WXZ[XWP[Z_UMYGNJ\L[JKLP4DODNOF_PN[NTPVHZ[XWP[ZD	]I_DOG	ina}qpj{pjazwl|mnjv_UMYGNJ\4L[JKLPyrq|rmeaaM]XaNGLV\SLPGacDODNOF_PN[NTPVHIQ[
HR_IQ[
HR_yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac|mnjv_UMYGNJ\`	IQ[
HR_yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac|mnjvSF]
TFJDRYN[aTSQUDQ
4C444XKP]JWQPYFRORF
PPKTSXaQDFYTWPKRR4E444F_aLRUKPPPL[LRXUaZV_DZYG	4WXF_aLRUKPPPL[L[JKLPX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTWFFXXaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBBGQS[a	
DD\SGLHVXaQDFYTWL[JKLPX_RM[4KSZ
H	MT
Hyrq|rmeaaM]Xa]FMXaRDGSQacF_aLRUKPPPL[4WX~yrq|rmeaaM]XaS

	ZLD	a
cKSZ
H	MT
HMO]\DJR_OJ
	ZVVPKSZ
H	MT
HJLK[444WX~yrq|rmeaaM]XaS

	ZLD	a
cKSZ
H	MT
HBB~yrq|rmeaaM]XaURRZW
ITGa
cKSZ
H	MT
HL[JKLPX_RM[44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[E4PFNNTPZ]KYLLGXD	WRM]	[DF_aLRUKPPPL[4WXyrq|rmeaaM]XaIMI

\G\\a
cPFNNTPZ]KPFNNTPZ]Kyrq|rmeaaM]XaaQKLGJP]_OIacPFNNTPZ]Kyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWL[JKLPJLK[444KPM[JPFNNTPZ]K4_]	]VV
FHQRGV	JVOR]WF_aLRUKPPPL[44WX_]	]VV
FHQPKRRH[LMWQPa]QSN_L[_]	]VV
FHQRINYW\WDWV_QNR
I	 L[JKLPX_RM[4KPM[J_]	]VV
FHQ4C444WXTO[]UPZVQVUTYTF_aLRUKPPPL[XaQDFYTWL[JKLPX_RM[4Y_HVRRKFFH]X
]VL
RF_aLRUKPPPL[
	
4Xa\
Qa\
N_TUF_aLRUKPPPL[4L[JKLPJLK[4C4XKP]JWQPVH	]TWI
]WDZG4E4XaQDFYTWPJYY\WJKRYWPPS44WXXaQDFYTWBBGQS[a	
DD\SGLHVXaQDFYTWL[JKLPX_RM[44aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
4G
SM	KLTZOJP[Hyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_KOPMXO	]LQZ[XWP[Z_UMYGNJ\	ina}qpj{pjazwl444WXG
SM	KLTZOJP[HL[JKLPX_RM[4YOW\[Y
OUZXG
SM	KLTZOJP[H_UMYGNJ\aGPQ]VFQS_Q44[
a\a\HQa
FZYOW\[Y
OUZXaGPQ]VFQS_QIQ[
HR_4YaS\KDMX_RM[444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4PI_aN_HNFGV	~yrq|rmeaaM]XaI	WS[XMPac[
a\a\HQa
FZ4G
GDOHVVHPLX~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4YaS\KDMyrq|rmeaaM]XaIMI

\G\\a
cPI_aN_HNFGV	yrq|rmeaaM]XaIMI

\G\\a
cG
GDOHVVHPLXPI_aN_HNFGV	G
GDOHVVHPLX4C4WXYaS\KDME4WX~yrq|rmeaaM]XaS

	ZLD	a
cYOW\[Y
OUZXMO]\DJR_OJ
	ZVVPYOW\[Y
OUZXF[FZXJLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
cYOW\[Y
OUZXBB~yrq|rmeaaM]XaURRZW
ITGa
cYOW\[Y
OUZXL[JKLPX_RM[4HUPRI_DF	H~yrq|rmeaaM]XaJSJX
DZZNIIJac[
a\a\HQa
FZYLLGXD	WRM]	[D[
a\a\HQa
FZX_RM[4WXHUPRI_DF	HPKRRyrq|rmeaaM]XaIMI

\G\\a
cHUPRI_DF	HBByrq|rmeaaM]XaaQKLGJP]_OIacHUPRI_DF	Hyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac[
a\a\HQa
FZE4_]	]VV
FHQRGV	JVOR]W[
a\a\HQa
FZ4WX_]	]VV
FHQPKRRH[LMWQPa]QSN_L[_]	]VV
FHQRINYW\WDWV_QNR
I	 L[JKLPX_RM[4444KPM[J_]	]VV
FHQ444C44WXTO[]UPZVQVUTYT[
a\a\HQa
FZG\VSaUWFRZGXaQDFYTWL[JKLPX_RM[4Y_HVRRKFFH]X
]VL
R[
a\a\HQa
FZ	
4I_HUSY[\MMDZQUH[
a\a\HQa
FZ4Xa\
Qa\
N_TU[
a\a\HQa
FZ44C4444KPM[JHUPRI_DF	H4C4SKG
JUGSHQKaGPQ]VFQS_QaGPQ]VFQS_QD	]I_DOG44I]F\\MV]P	LLKZSKG
JUGSHQK4L[JKLPJLK[4C4XKP]JWQPRGV	JVOR]WF_aLRUKPPPL[4E4SGDQ_VIHJ
XIMR~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[X_RM[PKRR
4WXyrq|rmeaaM]XaIMI

\G\\a
cSGDQ_VIHJ
XIMRL[JKLPPKRR4WXyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_SGDQ_VIHJ
XIMR]IFHJ	W_ML[JKLP]IFHJ	W_Mec4L[JKLPPKRR4C44XKP]JWQPaKIGURZU\I_P
SaFPOQNIaLXWKST
]S
	[U4E4~]R[_LMJ_J]_]V[JLK[POQNIaLXW44Iaa]O]SPU~yrq|rmeaaM]Xa_GRUDISIa	cPOQNIaLXW4WXIaa]O]SPUBBIaa]O]SPUTJ_	QLHU	YJSMDSOFE4444L[JKLPX_RM[4C4444ZMKUD
~yrq|rmeaaM]XaNDD_U_S]R\\acPOQNIaLXW4L[JKLPZMKUD
ZMKUD
 KST
]S
	[U4C4XKP]JWQPRXJYHGLQV	JRX4E4L[JKLP	4C4XKP]JWQPSWHLLXDFJUGMKT4444E4L[JKLPRYN[aTSQUDQ
4C4XKP]JWQPNZKPMO\X[I[U4E4L[JKLPD	]I_DOG4C4XKP]JWQPMNORNW	VP4E4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGL[JKLPJLK[4WXQL
WNPPWMYDN
LIL[JKLPJLK[4Y\\N\ITGULFyrq|rmeaaM]XaRJLRacMJLWPYyrq|rmeaaM]XaFOMVMVNG[KNac4WXY\\N\ITGULFSF]
TFJD
BByrq|rmeaaM]Xa_K_QN_\W	a]a	cY\\N\ITGULFXYTW[WWPHJQ_X_RM[L[JKLPJLK[4O
QSX_ZNMWMM[Jam{lh{leD	]I_DOGcyrq|rmeaaM]XaRJLRacMJLWPYam{lh{leSF]
TFJDc4WXO
QSX_ZNMyrq|rmeaaM]Xa_K_QN_\W	a]a	cO
QSX_ZNMD	]I_DOG	X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cO
QSX_ZNMD	]I_DOGX_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cO
QSX_ZNMD	]I_DOGX_RM[L[JKLPJLK[4L[JKLPX_RM[4C4XKP]JWQPQL
WNPPWMYDN
LI4E44O
QSX_ZNMWMM[Jam{lh{leRYN[aTSQUDQ
cam{lh{leSF]
TFJDc4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cO
QSX_ZNMMJLWNQMO
QSX_ZNMSF]
TFJDX_RM[4C4XKP]JWQP[]SUDZNOTUPNIZPaYMYD_D4E4IW
[M]ZHXa
MO]yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_~yrq|rmeaaM]Xa[PD\GWFacXYTW[WWPHJQ_X_RM[4WXIW
[M]ZHXa
MO]BBIW
[M]ZHXa
MO]L[JKLPJLK[4RaYLaVQFGaZ~yrq|rmeaaM]XaI	WS[XMPacNIZPaYMYD_D4WXRaYLaVQFGaZRaYLaVQFGaZNIZPaYMYD_D44XQL[_]Vyrq|rmeaaM]XaZLWL
M]XJPacnjvam{nljqlIW
[M]ZHXa
MO]_MZFNXLaR
WNWJSWE4ZFNXLaR
WNWJSWyrq|rmeaaM]XaNGLV\SLPGacZFNXLaR
WNWJSWSF]
TFJD4WXZFNXLaR
WNWJSWRaYLaVQFGaZZFNXLaR
WNWJSWBByrq|rmeaaM]Xa_K_QN_\W	a]a	cRaYLaVQFGaZZFNXLaR
WNWJSWzwl{}jqlgam{nljqlL[JKLPJLK[4C4L[JKLPX_RM[44C4XKP]JWQP][UDHHKG	LPXIKUX	OTZOF[	Z4E444R\WXTLZYOK_[UX	OTZOF[	ZBZ[XWP[ZRYN[aTSQUDQ
z|aps{BZ[XWP[ZIQ[
HR_|mnjv4L[JKLPyrq|rmeaaM]XaaQKLGJP]_OIacR\WXTLZYOK_[4C4XKP]JWQPZPO_XHQ_]L_ZUX	OTZOF[	Z4E4YRQ\_RINZ\4WXWMM[Jyrq|rmeIQ[
HR_
cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeD	]I_DOGcyrq|rme_UMYGNJ\c_LL_G4WX[SNJGyrq|rme_UMYGNJ\ceUX	OTZOF[	ZcE4WXWMM[Jyrq|rmeIQ[
HR_	ceUX	OTZOF[	Zcyrq|rmeaaM]XaJFVY[	SJPKa	cINZ\E4NYLPaFFNOGJZMWMM[JINZ\ Z\VINZ\ Z\VPKRR4WXNYLPaFFNOGJZMPKRRyrq|rmeIQ[
HR_	ceUX	OTZOF[	ZcNYLPaFFNOGJZME44KPM[Jyrq|rme_UMYGNJ\ceUX	OTZOF[	Zcyrq|rmeXYTW[WWPHJQ_	ceUX	OTZOF[	Zc4L[JKLPZPO_XHQ_]L_ZUX	OTZOF[	Z44C4KPM[JNYLPaFFNOGJZM4C4yrq|rmeIQ[
HR_ceUX	OTZOF[	Zc4L[JKLPJLK[4C4WXyrq|rmeaaM]XaJFVY[	SJPKa	cINZ\yrq|rmeaaM]Xa__VX_]O[acINZ\SF]
TFJDE444WGIQa[KKMI~INZ\ Y[JaH_LRYN[aTSQUDQ
][UDHHKG	LPXIKUX	OTZOF[	Z_UMYGNJ\444WXWGIQa[KKMIE4yrq|rmeXYTW[WWPHJQ_ceUX	OTZOF[	Zc4WXWMM[JINZ\ Z\VINZ\ Z\Vyrq|rmeIQ[
HR_	ceUX	OTZOF[	ZcINZ\ Z\V4L[JKLPJLK[4C4WXWGIQa[KKMIL[JKLPX_RM[4C4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4F	
\UH_UV_LL_G444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
F	
\UH_UVecyrq|rmeaaM]XaFHHDS]ZRTNa	c44WXZ[XWP[Z_UMYGNJ\F	
\UH_UVecina}qpj{pjazwl44WXZ[XWP[ZIQ[
HR_F	
\UH_UVecyrq|rmeaaM]XaNGLV\SLPGac|mnjvSF]
TFJD	4444XQL[_]VF	
\UH_UV_MKSZ
H	MT
HE4WXKSZ
H	MT
HBB~yrq|rmeaaM]XaS

	ZLD	a
cKSZ
H	MT
HBB~yrq|rmeaaM]XaURRZW
ITGa
cKSZ
H	MT
H]QPJWPK[4F_YHVVUUDFZT~yrq|rmeaaM]XaYVI_UURR
OPacKSZ
H	MT
HIQ[
HR_][UDHHKG	LPXIKUX	OTZOF[	ZIQ[
HR_]4WXF_YHVVUUDFZTX_RM[E4WX~XRQ]UF_YHVVUUDFZTrq}ua{fBrq}uap|E4~X]RQM[F_YHVVUUDFZT4L[JKLPX_RM[4C44WXWMM[Jyrq|rmeSF]
TFJDcBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeXYTW[WWPHJQ_cyrq|rmeIQ[
HR_c_LL_G444yrq|rmeIQ[
HR_ceUX	OTZOF[	ZcF_YHVVUUDFZT4yrq|rmeRYN[aTSQUDQ
ceUX	OTZOF[	Zc44L[JKLPJLK[4C4C4C4yrq|rmeXYTW[WWPHJQ_ceUX	OTZOF[	Zc4yrq|rmeXYTW[WWPHJQ_ceUX	OTZOF[	Zc4L[JKLPJLK[4C4XKP]JWQPFT_Q_YTVaGTUX	OTZOF[	Z4E4YRQ\_RINZ\44WX[SNJGyrq|rmeD	]I_DOGceUX	OTZOF[	ZcL[JKLP4yrq|rmeSF]
TFJDceUX	OTZOF[	Zc4WXyrq|rmeXYTW[WWPHJQ_ceUX	OTZOF[	Zc L[JKLP4KPM[Jyrq|rmeD	]I_DOGceUX	OTZOF[	Zc4KPM[Jyrq|rmeD	]I_DOGceUX	OTZOF[	Zc4KPM[Jyrq|rmeD	]I_DOGceUX	OTZOF[	Zc4WXWMM[Jyrq|rmeSF]
TFJDceUX	OTZOF[	ZcE4~XRQ]Uyrq|rmeRYN[aTSQUDQ

ceUX	OTZOF[	Zcrq}uakp4~X]RQM[yrq|rmeRYN[aTSQUDQ
ceUX	OTZOF[	Zc444KPM[Jyrq|rmeIQ[
HR_ceUX	OTZOF[	Zc4C4WXyrq|rmeaaM]XaJFVY[	SJPKa	cINZ\yrq|rmeaaM]Xa__VX_]O[acINZ\SF]
TFJDE4~INZ\ OK[LGSF]
TFJD	][UDHHKG	LPXIKUX	OTZOF[	ZSF]
TFJD4C44C4XKP]JWQPHP\aHPIQY]M[4444E4WXZ[XWP[ZIQ[
HR_zwmrrqiaxwr{asqzmL[JKLPX_RM[4L[JKLPJLK[4444C4XKP]JWQPQUFNT
FOHKSZNF	Z4E4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
BByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
L[JKLPX_RM[4UQD
PKQNQPVTU_LL_G444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

UQD
PKQNQPVTUecyrq|rmeaaM]XaFHHDS]ZRTNa	c4WXZ[XWP[ZSF]
TFJDUQD
PKQNQPVTUecina}qpj{pjazwl4WXZ[XWP[Z_UMYGNJ\UQD
PKQNQPVTUecyrq|rmeaaM]XaNGLV\SLPGac|mnjvRYN[aTSQUDQ
	4XQL[_]VUQD
PKQNQPVTU_M_JK[	N]VHYQYE4WX_JK[	N]VHYQYBB~yrq|rmeaaM]XaS

	ZLD	a
c_JK[	N]VHYQYBB~yrq|rmeaaM]XaURRZW
ITGa
c_JK[	N]VHYQY]QPJWPK[4FKNI\~yrq|rmeaaM]XaYVI_UURR
OPac_JK[	N]VHYQYRYN[aTSQUDQ
][UDHHKG	LPXIKD	]I_DOG
XYTW[WWPHJQ_
]444WXFKNI\X_RM[]QPJWPK[4444WX~XRQ]UFKNI\rq}ua{fBrq}uap|E4~X]RQM[FKNI\4L[JKLPX_RM[4C4yrq|rmeXYTW[WWPHJQ_
cFKNI\4L[JKLPJLK[4C4L[JKLPX_RM[444C4XKP]JWQPIK
QM[U
[SNJJI	44E4WXWMM[Jyrq|rmeIQ[
HR_
cE4444~XRQ]Uyrq|rmeD	]I_DOG
crq}uakp4~X]RQM[yrq|rmeSF]
TFJD
c4KPM[Jyrq|rme_UMYGNJ\
c4C444C4XKP]JWQPI]F\\MV]P	LLKZSKG
JUGSHQK4E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD

BByrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
L[JKLP4WXQUFNT
FOHKSZNF	ZL[JKLP4JLGE4]S_TJJ	_O\RWY[JaQNJWQPRYN[aTSQUDQ

_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
c]S_TJJ	_O\RW]S_TJJ	_O\RW_LL_G4444]VHVaZVRa_J[Gyrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaUYGQMULaFLa
c]S_TJJ	_O\RW4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cSKG
JUGSHQK]VHVaZVRa_J[GJLK[]VHVaZVRa_J[GecSKG
JUGSHQK4WX]VHVaZVRa_J[G]S_TJJ	_O\RWKNZ_J[aQNJWQP_UMYGNJ\
]VHVaZVRa_J[G4KPM[J]VHVaZVRa_J[G444CXWP_RRGE4IK
QM[U
[SNJJI	444C4C4XKP]JWQPFJ\X	aMXSaVRYX]SKG
JUGSHQK4E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD

BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
L[JKLP444WXQUFNT
FOHKSZNF	ZL[JKLP4JLGE4]S_TJJ	_O\RWY[JaQNJWQPRYN[aTSQUDQ

_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
c]S_TJJ	_O\RWyrq|rmeaaM]Xa_LHMQPFPD
Ma
cSKG
JUGSHQK]S_TJJ	_O\RWJLK[E4KNZ_J[aQNJWQPRYN[aTSQUDQ

yrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaaVYPVSS
ac]S_TJJ	_O\RW_LL_GSKG
JUGSHQK4C4CXWP_RRGE4IK
QM[U
[SNJJI	4C4444C4XKP]JWQPQWVIDDHOPHQ[VKZM_GYZIFZaSQ	MNQOPFD4E4JLGE4WXWPJ[LX_][a[FWMJMSF]
TFJDQ	MNQOPFDWPMJ_P][QXjVLQI_\R[E4NW_\DH	Y[_Ryrq|rmeaaM]Xa[NP\	U	ac_GYZIFZaSD	]I_DOGQ	MNQOPFD Y[Js[MM_Y[F\[F
4C[RM[WXQ	MNQOPFDWPMJ_P][QX{F][NJWQPE4NW_\DH	Y[_Ryrq|rmeaaM]Xa[NP\	U	ac_GYZIFZaS_UMYGNJ\Q	MNQOPFD Y[Js[MM_Y[

4C[RM[WXyrq|rmeaaM]XaIMI

\G\\a
cQ	MNQOPFDyrq|rmeaaM]XaNJ]SSODDIGGaacQ	MNQOPFD E4NW_\DH	Y[_Ryrq|rmeaaM]Xa[NP\	U	ac_GYZIFZaSSF]
TFJDQ	MNQOPFD
4C[RM[E4L[JKLP4C444WXWMM[Jyrq|rmeRYN[aTSQUDQ
cyrq|rmeRYN[aTSQUDQ
c_LL_G4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cNW_\DH	Y[_Ryrq|rmeIQ[
HR_
cJLK[E4yrq|rmeD	]I_DOG
cecNW_\DH	Y[_R4C444WXyrq|rmeaaM]XaOG\FSVKacyrq|rmeXYTW[WWPHJQ_c FZFE4yrq|rme_UMYGNJ\cyrq|rmeaaM]XaRSVOIDaFHTJacyrq|rmeSF]
TFJDc
4C4C]_J]VjVLQI_\R[[]\]M_	WU\UZHE4C]_J]V{F][NJWQP[]\]M_	WU\UZHE4C4C4444XKP]JWQP\GXT\HI_L]RNSGDQ_VIHJ
XIMR_U
D[N	FYQMQYF_aLRUKPPPL[PLX
MHTUP4E4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	L[JKLPX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
c_U
D[N	FYQMQYE4L[JKLP_ZZa_]JWQPSGDQ_VIHJ
XIMRXKP]JWQPKYP\VDPJFKM[_U
D[N	FYQMQYE44WXyrq|rmeaaM]XaIVPaITaGa
c_U
D[N	FYQMQYL[JKLP_U
D[N	FYQMQYKYP\VDPJF4L[JKLPPKRR4CF_aLRUKPPPL[PLX
MHTUP4C4L[JKLP_ZZa_]JWQPSGDQ_VIHJ
XIMR_U
D[N	FYQMQYF_aLRUKPPPL[PLX
MHTUP4C4XKP]JWQPUMZ\ZOXL_IJXFQXSGDQ_VIHJ
XIMR_U
D[N	FYQMQYF_aLRUKPPPL[PLX
MHTUP44E4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\L[JKLPX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
c_U
D[N	FYQMQYE4L[JKLP_ZZaXWRJ[LSGDQ_VIHJ
XIMRXKP]JWQPKYP\VDPJFKM[_U
D[N	FYQMQYE4WXyrq|rmeaaM]XaIVPaITaGa
c_U
D[N	FYQMQYL[JKLP_U
D[N	FYQMQYKYP\VDPJF4L[JKLPWMM[JKYP\VDPJFecKYP\VDPJFecPKRR4CF_aLRUKPPPL[PLX
MHTUP4C4L[JKLP_ZZaXWRJ[LSGDQ_VIHJ
XIMR_U
D[N	FYQMQYF_aLRUKPPPL[PLX
MHTUP444C4XKP]JWQPMGUOK\T\L]4444E4ZFNXLaR
WNWJSWZ[XWP[ZRYN[aTSQUDQ
ina}qpj{pjazwl_UMYGNJ\YFJN
WLK\P|mnjvSF]
TFJDyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPSF]
TFJD44WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSW[]SUDZNOTUPZFNXLaR
WNWJSWE4MO]\DJR_OJ
	ZVVPZFNXLaR
WNWJSW
JLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWE4U
]TV\
IZDSUZFNXLaR
WNWJSWXYTW[WWPHJQ_NVNmWR[P][WMYQRZ[PbPD	]I_DOG4C4444C4WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSW~yrq|rmeaaM]XaURRZW
ITGa
cZFNXLaR
WNWJSWE4L[JKLPZFNXLaR
WNWJSW444C4UaJ_FM_Lyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4WX~yrq|rmeaaM]XaS

	ZLD	a
cUaJ_FM_L[]SUDZNOTUPUaJ_FM_LMO]\DJR_OJ
	ZVVPUaJ_FM_L

	JLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
cUaJ_FM_L~yrq|rmeaaM]XaURRZW
ITGa
cUaJ_FM_LL[JKLPUaJ_FM_L4DL\T
U\_OYFyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP4WX~yrq|rmeaaM]XaURRZW
ITGa
cDL\T
U\_OYFDL\T
U\_OYF\PQQYLWZWNM]_KPL[JKLPDL\T
U\_OYF4WXZ[XWP[Z_UMYGNJ\
~yrq|rmeaaM]XaURRZW
ITGa
cina}qpj{pjazwl[]SUDZNOTUPina}qpj{pjazwlL[JKLPina}qpj{pjazwl4L[JKLPZFNXLaR
WNWJSW4C4XKP]JWQPKOPMXO	]LQ4E4WXZ[XWP[ZD	]I_DOG
~yrq|rmeaaM]XaURRZW
ITGa
cina}qpj{pjazwl[]SUDZNOTUPina}qpj{pjazwlL[JKLPina}qpj{pjazwl44PTL	RZ]JXJYO]yrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP4WX[]SUDZNOTUPPTL	RZ]JXJYO]L[JKLPPTL	RZ]JXJYO]444L[JKLPina}qpj{pjazwl4C4444XKP]JWQP\J

DH]GQG	FQINIZPaYMYD_D4E4WX[SNJGyrq|rmeXYTW[WWPHJQ_cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeSF]
TFJDcL[JKLPX_RM[4WXWMM[Jyrq|rmeSF]
TFJDceNIZPaYMYD_DcL[JKLPJLK[44RaYLaVQFGaZyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	~yrq|rmeaaM]XaI	WS[XMPacNIZPaYMYD_DX_RM[4L[JKLPRaYLaVQFGaZX_RM[WMM[Jyrq|rme_UMYGNJ\ceRaYLaVQFGaZc4C4444XKP]JWQPNGWWUNHW]Z[KG]SOONIZPaYMYD_D444E4444WX[SNJGyrq|rmeIQ[
HR_cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeIQ[
HR_cL[JKLP4KPM[Jyrq|rmeIQ[
HR_	ceNIZPaYMYD_Dc4RaYLaVQFGaZyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~yrq|rmeaaM]XaI	WS[XMPacNIZPaYMYD_DX_RM[4WXRaYLaVQFGaZX_RM[KPM[Jyrq|rmeRYN[aTSQUDQ
	ceRaYLaVQFGaZc4C44XKP]JWQP]\PVKDPXDNGR]aTNIZPaYMYD_D4E4WXWMM[Jyrq|rmeXYTW[WWPHJQ_	cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeRYN[aTSQUDQ
	cE4yrq|rmeXYTW[WWPHJQ_	c_LL_G4C4WWXHUUPXXRyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	~yrq|rmeaaM]XaI	WS[XMPacNIZPaYMYD_DX_RM[4yrq|rmeD	]I_DOG	ceWWXHUUPXXRX_RM[WWXHUUPXXRNIZPaYMYD_DcNIZPaYMYD_D4MJ_JW]THPSYYD
OPXDWRX_RM[4WXTHPSYYD
OPXDWRE444THPSYYD
OPXDWRJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	yrq|rmeaaM]XaKQTGQ
Na	c_UMYGNJ\	44C4444C4XKP]JWQPL
PHKLL__QOOMPPG_4E4WX[SNJGyrq|rmeD	]I_DOG	
cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeRYN[aTSQUDQ
	
cE444L[JKLP44C4XQL[_]Vyrq|rmeRYN[aTSQUDQ
	c_MJPODSWQWSL_ TQNJJHOLE4WXyrq|rmeaaM]XaIMI

\G\\a
cTQNJJHOLTQNJJHOLJPODSWQWSL_4WXJPODSWQWSL_XTDWYLRT_NPTYMLPBBTQNJJHOLXTDWYLRT_NPTYMLP]QPJWPK[4JLGE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacTQNJJHOLY[D\QVWZZP_TQNJJHOLMQ\WLYZaV
PWT	KHUZTQNJJHOLE4IHPXVXNL_VN\MGYaMTQNJJHOL4[TSM]VFID	aQPDTQNJJHOL4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4C4XKP]JWQPaSGIUHYGHKXPVUaP4E44JLGE4Q	MNQOPFDyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	~[LLQLaY[JaR_MJPKRR4WXyrq|rmeaaM]Xa]HYHVUa
cQ	MNQOPFDBB[SNJGQ	MNQOPFDe_UMYGNJ\		cBB[SNJGQ	MNQOPFDe_UMYGNJ\	cL[JKLP4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cQ	MNQOPFDeSF]
TFJD	c_LL_G{a{llql{anlm{{a}ql{a{llql{a}qsnwr{a{llql{akm{la{llqlJLK[L[JKLP4]IFHJ	W_MWMM[JQ	MNQOPFDe_UMYGNJ\cMJLWPYQ	MNQOPFDeXYTW[WWPHJQ_c4WXMJLWNQM]IFHJ	W_M_UMYGNJ\X_RM[BBMJLWNQM]IFHJ	W_M_UMYGNJ\X_RM[L[JKLP4YaS\KDMyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLPXTDWYLRT_NPTYMLP4a[Xyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~yrq|rmeaaM]XaI	WS[XMPacQ	MNQOPFDeD	]I_DOGcQ	MNQOPFDeSF]
TFJDc4WXyrq|rmeaaM]XaIMI

\G\\a
cYaS\KDMBByrq|rmeaaM]XaIMI

\G\\a
ca[XBBa[XYaS\KDML[JKLP4WXWMM[Jyrq|rme_UMYGNJ\	cE4VYLNJIZVJ~yrq|rmeaaM]XaHSO\NMa_Da
cXTDWYLRT_NPTYMLPX_RM[PKRRF]
F\X4WXyrq|rmeaaM]XaIMI

\G\\a
cVYLNJIZVJyrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJDVYLNJIZVJaZSaZSecMJLWPYyrq|rmeXYTW[WWPHJQ_cL[JKLP4KPM[JVYLNJIZVJaZS44WXWMM[Jyrq|rmeSF]
TFJDcE44WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~]R[_LMJ_J]_]V[JLK[XTDWYLRT_NPTYMLP4\]T	NVDOMT_FMJLWPY~yrq|rmeaaM]XaNDD_U_S]R\\acXTDWYLRT_NPTYMLPMJLWPY~yrq|rmeaaM]Xa_GRUDISIa	cXTDWYLRT_NPTYMLP4WX\]T	NVDOMT_FMJLWPYyrq|rmeRYN[aTSQUDQ
cL[JKLP4KPM[J\]T	NVDOMT_F444C44C44aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4aTIH	[]XL[[YLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4ORY_IJLQ\VYS\yrq|rmeaaM]XaIMI

\G\\a
caTIH	[]XL[[yrq|rmeaaM]XaaQKLGJP]_OIacaTIH	[]XL[[4KPM[JaTIH	[]XL[[4WXORY_IJLQ\VYS\E4U
]TV\
IZDSUyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPD	]I_DOGaGPQ]VFQS_QORY_IJLQ\VYS\O4U
]TV\
IZDSUyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP_UMYGNJ\
ORY_IJLQ\VYS\MJLWPYyrq|rmeaaM]XaD]SGTYaFPQHDacO4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
E44~KNZ_J[aQNJWQP_UMYGNJ\ORY_IJLQ\VYS\Byrq|rmeaaM]XaD]SGTYaFPQHDac_UMYGNJ\	4C4C444HXG_NW]N	\PQQYLWZWNM]_KP44WXORY_IJLQ\VYS\HXG_NW]N	yrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	~yrq|rmeaaM]XaURRZW
ITGa
cHXG_NW]N	E4U
]TV\
IZDSUHXG_NW]N	_UMYGNJ\aGPQ]VFQS_QORY_IJLQ\VYS\O444C44FJ\X	aMXSaVRYX]QFSXaFSW[	_4PTaaNIZYOT
I_aIQ[
HR_4NR\M_XTKXTDWYLRT_NPTYMLPIQ[
HR_4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	
~yrq|rmeaaM]XaR
[HRNLSDPHa	
cXTDWYLRT_NPTYMLPNR\M_XTK4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4~QN]_]V[aWPH_RWZ_J[XTDWYLRT_NPTYMLPJLK[4~QN]_]V[aWPH_RWZ_J[NR\M_XTKJLK[4C4XQL[_]V_LL_Gyrq|rmeaaM]Xa]FMXaRDGSQacNR\M_XTK\PQQYLWZWNM]_KP_MHKaJ[SUOULWHE4\R\H\ILHS[QLP]KURFMDRXHKaJ[SUOULWH
4WXyrq|rmeaaM]Xa]HYHVUa
c\R\H\ILHS[]QPJWPK[4XQL[_]V\R\H\ILHS[_MXZOILNJ_JE4444WXyrq|rmeaaM]Xa[NP\	U	acXZOILNJ_JFFSF]
TFJD]QPJWPK[4R
OIQXNHKaJ[SUOULWHXZOILNJ_J4[XZDLHQVK~yrq|rmeaaM]Xa_GRUDISIa	cR
OIQXN4WX[XZDLHQVK[XZDLHQVKyrq|rmeaaM]XaD]SGTYaFPQHDac
E4Y_HVRRKFFH]X
]VL
RR
OIQXN4444_I	Q]G
P
R
OIQXN4C44C444C4KPM[JHKaJ[SUOULWH\R\H\ILHS[XZOILNJ_JR
OIQXN[XZDLHQVK4C]_J]VjVLQI_\R[[]\]M_	WU\UZHE4C]_J]V{F][NJWQP[]\]M_	WU\UZHE4C4C4XKP]JWQP\LaVOQQHKFWIPNIZPaYMYD_DHQ[SYLHQLG]VJ4E4JLGE4WXyrq|rmeaaM]XaIMI

\G\\a
cNIZPaYMYD_DBBNIZPaYMYD_DBByrq|rmeaaM]XaIMI

\G\\a
cHQ[SYLHQLG]VJBBHQ[SYLHQLG]VJL[JKLP4ZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D4WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWBB~yrq|rmeaaM]XaURRZW
ITGa
cZFNXLaR
WNWJSWL[JKLP4PQSU]RQIHYZFNXLaR
WNWJSWIQ[
HR_yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_DD	]I_DOG4\GWP[WUJHGRN~yrq|rmeaaM]XaHSO\NMa_Da
cPQSU]RQIHY4WXyrq|rmeaaM]XaIMI

\G\\a
c\GWP[WUJHGRNyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
\GWP[WUJHGRN]IFHJ	W_MH[LMWQPa]QSN_L[]IFHJ	W_MecHQ[SYLHQLG]VJXYTW[WWPHJQ_L[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
~yrq|rmeaaM]XaUM_SDP\\\a
cPQSU]RQIHYHQ[SYLHQLG]VJ4C]_J]VjVLQI_\R[Q	MNQOPFDE444C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPSFaYJ
TI	D
MaG4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\

E4L[JKLP4C4WX~Y[JaQNJWQPXYTW[WWPHJQ_E4\GXT\HI_L]RNSF]
TFJDD	]I_DOG	4C4444WXZPO_XHQ_]L_Z_UMYGNJ\L[JKLP44YKYRaNa

Uyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac|mnjvMJLWPYTJ_	QLHU	YJSMDSOF4H\ZNVO_LaNMJLWPY~Y[JaQNJWQPYKYRaNa

U4L[T\U
\
Y\[RYN[aTSQUDQ
4444DDZM_O]S\44N\DYQNFW]FMJLL[HVKYYDIHNYQPMT4J	OUTVS
KRINYW\WDWV_QNR
I	4ZGUUJ	OUTVS
KBN\DYQNFW]F44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cH\ZNVO_LaNBX_RM[E4QJK_ZXNLJITM_yrq|rmeaaM]XaZLWL
M]XJPacBH\ZNVO_LaN4L[T\U
\
Y\[QJK_ZXNLJITM_ec4DDZM_O]S\QJK_ZXNLJITM_ec4C[RM[E44DDZM_O]S\H\ZNVO_LaN4C44WXDDZM_O]S\E44~KNZ_J[aQNJWQPYKYRaNa

UZGUURYN[aTSQUDQ
4L[JKLP444C44WXDDZM_O]S\N\DYQNFW]FE4WXH\ZNVO_LaNZGUUH[LMWQPa]QSN_L[J	OUTVS
KL[T\U
\
Y\[RYN[aTSQUDQ
E4~KNZ_J[aQNJWQPYKYRaNa

UZGUUXYTW[WWPHJQ_444C4L[JKLP4C44QU[P	[OWHL[O	MJLL[HDDZM_O]S\4WXQU[P	[OWHL[O	BByrq|rmeaaM]Xa[KDO
YMUaR\VacQU[P	[OWHL[O	QU[P	[OWHL[O	E44~KNZ_J[aQNJWQPYKYRaNa

UZGUURYN[aTSQUDQ
4L[JKLP4C44IKDOY
J	aFP\PQQYLWZWNM]_KPQU[P	[OWHL[O	444\
WSS
ZZNRF
W4WXZ[XWP[ZRYN[aTSQUDQ
E44\
WSS
ZZNRF
Winanrkywpazwlyrq|rmeaaM]XaQVIZMF
UWMPacQU[P	[OWHL[O	njvwpxqaxwr{ps{QU[P	[OWHL[O	4444C44UH]ZG]OFWJX
~yrq|rmeaaM]XaNDD_U_S]R\\acIKDOY
J	aFP4NJJ]	P][\FRU_UH]ZG]OFWJX
X_RM[UH]ZG]OFWJX
 	4IRDJXR_KWY\
WSS
ZZNRF
W~yrq|rmeaaM]XaNDD_U_S]R\\ac\
WSS
ZZNRF
WX_RM[4L
KVVMKJP_IRDJXR_KWYX_RM[IRDJXR_KWY 

44WXNJJ]	P][\FRU_L
KVVMKJP_E4~KNZ_J[aQNJWQPYKYRaNa

UZGUUXYTW[WWPHJQ_4L[JKLP4C4444MMSRU\YaWNJJ]	P][\FRU_IKDOY
J	aFP\
WSS
ZZNRF
W4FKNI\~yrq|rmeaaM]XaHSO\NMa_Da
cMMSRU\YaWX_RM[PKRR

4WXyrq|rmeaaM]XaIMI

\G\\a
cFKNI\yrq|rmeaaM]Xa_[
SWPR]Nac_UMYGNJ\FKNI\aXSE4L[T\U
\
Y\[aXSec4C[RM[WXaKIGURZU\I_P
SaFMMSRU\YaW
		E4444L[T\U
\
Y\[IQ[
HR_4444C4KPM[JFKNI\aXS4SOKFKLU_XG_ITPNJJ]	P][\FRU_4WXSOKFKLU_XG_ITPL
KVVMKJP_E4RFVJQJ\_RUDKO]yrq|rmeaaM]XaQVIZMF
UWMPacQU[P	[OWHL[O	njvwpxqaxwr{ps{QU[P	[OWHL[O	44TJXD]UWa\YDK__LL_G~Y[JaQNJWQPSF]
TFJD
_LL_G4SOKFKLU_XG_ITPyrq|rmeaaM]Xa_LHMQPFPD
Ma
cRFVJQJ\_RUDKO]TJXD]UWa\YDK_JLK[4WXSOKFKLU_XG_ITPyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
WMaSKRJWMWJ[yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4DJ\HFTTQJJ_LL_G~Y[JaMWJ[aQNJWQPRYN[aTSQUDQ
_LL_G4SOKFKLU_XG_ITPWMM[JDJ\HFTTQJJeRFVJQJ\_RUDKO]c4KPM[JDJ\HFTTQJJ4C4KPM[JRFVJQJ\_RUDKO]TJXD]UWa\YDK_4C4_SH]RVHN
M]JH[LMWQPa]QSN_L[J	OUTVS
KL[T\U
\
Y\[4WX_SH]RVHN
M]JE4HQQHHPLQTSaIO_aKIGURZU\I_P
SaFMMSRU\YaW


4O\PPIZ_
VUFWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acMMSRU\YaW4PZLRH\ITSG[PHQQHHPLQTSaIO_BBO\PPIZ_
VUF F	
F]]\_4WXPZLRH\ITSG[PO\PPIZ_
VUF 

E4\[HP]ML~yrq|rmeaaM]XaHSO\NMa_Da
cMMSRU\YaWX_RM[PKRR
4WXyrq|rmeaaM]XaIMI

\G\\a
c\[HP]MLBByrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJD	\[HP]MLPZLRH\ITSG[PJLK[44C4WXPZLRH\ITSG[PJXQZWQYO][P\VZMMSRU\YaWPZLRH\ITSG[PJLK[4WXPZLRH\ITSG[PE44TJ
Y	[ZVaZZ	\YYFLN]J\S]QRWHRR4WX[SNJGTJ
Y	[ZVaZZ	\e_UMYGNJ\cE444LVOGH	TDFG~yrq|rmeaaM]XaI	WS[XMPacTJ
Y	[ZVaZZ	\e_UMYGNJ\c4JSOVIY_RSRU
UP~yrq|rmeaaM]XaI	WS[XMPacMMSRU\YaW4444WXyrq|rmeaaM]XaIMI

\G\\a
cLVOGH	TDFGyrq|rmeaaM]XaIMI

\G\\a
cJSOVIY_RSRU
UPLVOGH	TDFGJSOVIY_RSRU
UPE4H]HVXaJaTKH_JGFTZLTG]TJ
Y	[ZVaZZ	\444WXH]HVXaJaRYN[aTSQUDQ
BBH]HVXaJaXYTW[WWPHJQ_PZLRH\ITSG[PJLK[4C4KPM[JLVOGH	TDFGJSOVIY_RSRU
UPH]HVXaJa4444C4WXPZLRH\ITSG[PPa
X\SYQJTY	
][YKMMSRU\YaWPZLRH\ITSG[PJLK[4KPM[JTJ
Y	[ZVaZZ	\4C4WXPZLRH\ITSG[PE4444WXHQQHHPLQTSaIO_]\PVKDPXDNGR]aTMMSRU\YaW4~KNZ_J[aQNJWQPYKYRaNa

UZGUU_UMYGNJ\4L[JKLP4C4WXSOKFKLU_XG_ITPE4~KNZ_J[aQNJWQPYKYRaNa

UZGUUSF]
TFJD4L[JKLP4C4WXM]VKWGRWZRNYMMSRU\YaWXTDWYLRT_NPTYMLPE4~KNZ_J[aQNJWQPYKYRaNa

UZGUURYN[aTSQUDQ
4L[JKLP4C4WX_SH]RVHN
M]JBB_SH]RVHN
M]Jyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJDyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacyrq|rmeaaM]Xa[KDO
YMUaR\VacQU[P	[OWHL[O	D	]I_DOGE4\LaVOQQHKFWIPXTDWYLRT_NPTYMLPL[T\U
\
Y\[4_MZHILSNMSLG
QXTDWYLRT_NPTYMLP4L[JKLPJLK[4C44C4WX[SNJGyrq|rmeRYN[aTSQUDQ
cE4yrq|rmeXYTW[WWPHJQ_cJLK[44WXaKIGURZU\I_P
SaFMMSRU\YaWFF_]\PVKDPXDNGR]aTMMSRU\YaW4FWRZUGUyrq|rmeaaM]XaD]SGTYaFPQHDac4GTOMLTaWMG
IQPG
XTDWYLRT_NPTYMLPFWRZUGUFWRZUGU
TJ_	QLHU	YJSMDSOF4KPM[JFWRZUGU4\LaVOQQHKFWIPIKDOY
J	aFPJ	OUTVS
K4WX\
WSS
ZZNRF
W\LaVOQQHKFWIP\
WSS
ZZNRF
WJ	OUTVS
K4\GXT\HI_L]RN_UMYGNJ\XYTW[WWPHJQ_4~KNZ_J[aQNJWQPYKYRaNa

UZGUUXYTW[WWPHJQ_
4PTaaNIZYOT
I_aSF]
TFJD4WX\
WSS
ZZNRF
WE4FJ\X	aMXSaVRYX]yrq|rmeaaM]XaQVIZMF
UWMPacQU[P	[OWHL[O	njvwpxqaxwr{ps{QU[P	[OWHL[O	4C44C4L[JKLP4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4CXWP_RRGE4FT_Q_YTVaGTD	]I_DOG44C4C444XKP]JWQPQLP]KURFMDRXZFNXLaR
WNWJSWTM]L[	YVF444E4TM]L[	YVFWPJTM]L[	YVF4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4NM]WZRVMRK~yrq|rmeaaM]XaaD_[
OPQ\JDLa	cZFNXLaR
WNWJSW4WXNM]WZRVMRKE4VGaX
KNKaFQY_LL_G4IVWR[Q	MNQOPFD~yrq|rmeaaM]XaGZSMV_XPGQNacNM]WZRVMRKX_RM[E4WXQ	MNQOPFDQ	MNQOPFDXYTW[WWPHJQ_

VGaX
KNKaFQYecQ	MNQOPFD4WXTM]L[	YVF yrq|rmeaaM]XaOG\FSVKacVGaX
KNKaFQY TM]L[	YVF\L[_U4C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_~yrq|rmeaaM]XaO	SDSSQ]YRLacNM]WZRVMRK4L[JKLPVGaX
KNKaFQY4C4C4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
E4444WGIQa[KKMI~yrq|rmeaaM]XaPWQFKO
D
LacZFNXLaR
WNWJSW4WXyrq|rmeaaM]Xa]HYHVUa
cWGIQa[KKMIE4WGIQa[KKMIyrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaaVYPVSS
acWGIQa[KKMI_LL_GXYTW[WWPHJQ_

444WXTM]L[	YVF yrq|rmeaaM]XaOG\FSVKacWGIQa[KKMI TM]L[	YVFWGIQa[KKMIyrq|rmeaaM]XaRSVOIDaFHTJacWGIQa[KKMITM]L[	YVF4L[JKLPWGIQa[KKMI4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4QaIW
Ka~yrq|rmeaaM]Xa\TOUSOOMFG\a	cZFNXLaR
WNWJSWSF]
TFJD4WXyrq|rmeaaM]Xa]HYHVUa
cQaIW
KaE4WXTM]L[	YVF yrq|rmeaaM]XaOG\FSVKacQaIW
Ka TM]L[	YVFQaIW
Kayrq|rmeaaM]XaRSVOIDaFHTJacQaIW
KaTM]L[	YVF4L[JKLPyrq|rmeaaM]XaOP\[VSWFHacRYN[aTSQUDQ
QaIW
Ka4C4C444L[JKLPPKRR4C4XKP]JWQPGY	\aPMQJU
ZJFRSJPQN	QR4E4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
L[JKLPPKRR444SMXJGSM]IIyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
MJLWPY~yrq|rmeaaM]Xa[PD\GWFac_UMYGNJ\4WXSMXJGSM]IIMJLWNQMSMXJGSM]IIXYTW[WWPHJQ_
X_RM[L[JKLPPKRR4WXVJMKMS[PSPGWN[P	
XIISPKyrq|rmeaaM]XaFHHDS]ZRTNa	cXYTW[WWPHJQ_4444WXWXVJMKMS[PX_RM[L[JKLPPKRR4WX~yrq|rmeaaM]XaUM_SDP\\\a
cWXVJMKMS[PSJPQN	QRyrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QRE4_I	Q]G
P
WXVJMKMS[P4444L[JKLPPKRR4C4OGWU\H]IWX\~yrq|rmeaaM]Xa_ZISTM[HKJa
cIQ[
HR_[M]_N[MV[RR_LYWXVJMKMS[PSF]
TFJD	4_I	Q]G
P
WXVJMKMS[P4WXyrq|rmeaaM]XaIMI

\G\\a
cOGWU\H]IWX\BBOGWU\H]IWX\L[JKLPPKRR4WXMJLWNQMOGWU\H]IWX\RYN[aTSQUDQ
X_RM[L[JKLPJLK[4WXMJLWNQMOGWU\H]IWX\RYN[aTSQUDQ
X_RM[BBMJLWNQMOGWU\H]IWX\IQ[
HR_
X_RM[L[JKLPX_RM[4L[JKLPPKRR4C4XKP]JWQPGQS[a	
DD\SGLHVSJPQN	QR4E4MJ_JW]HYNMHYUSKNG_LL_G4WXyrq|rmeaaM]XaIMI

\G\\a
cSJPQN	QRBByrq|rmeaaM]Xa_K_QN_\W	a]a	cSJPQN	QRSF]
TFJD
X_RM[L[JKLPX_RM[4WXyrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QR FZFZX[[SJPQN	QRT_DLVDPGFPFPaDQRKSJPQN	QR4WXyrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QR 
L[JKLPX_RM[444WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
L[JKLPJLK[4]N]L	LM	Myrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QRyrq|rmeaaM]XaaQKLGJP]_OIacSJPQN	QR4WXyrq|rmeaaM]Xa\[X\\K[PFa
c]N]L	LM	MHYNMHYUSKNGL[JKLPHYNMHYUSKNGe]N]L	LM	Mc4[WZ]\VKUSZJD]SDSHYDSJPQN	QR4WXyrq|rmeaaM]XaOG\FSVKacHYNMHYUSKNG F\FZHYNMHYUSKNG_LL_G4HYNMHYUSKNGe]N]L	LM	Mc[WZ]\VKUS4L[JKLP[WZ]\VKUS4C4XKP]JWQPZJD]SDSHYDSJPQN	QR4E4WXZ[XWP[ZSF]
TFJD

E444OaGRKFGP[PGJGXG
[XY	_aR
D
Gyrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QR4WXOaGRKFGP[PGJE4U]FXM
_LKW~JQU[PaY[Ja_RRSJPQN	QR4WXyrq|rmeaaM]Xa]HYHVUa
cU]FXM
_LKWL[JKLPJLK[44UK[FSPRJ4QLDTSRZP4]RYUFMX4XQL[_]VU]FXM
_LKW_MQIQKFOXaHE444WXyrq|rmeaaM]Xa]HYHVUa
cQIQKFOXaHE4WXQIQKFOXaHecja}klrgaqn{pBBQIQKFOXaHecjazqrrlaqn{pa}klrga|l}{mUK[FSPRJ4]QPJWPK[4C4444WXQIQKFOXaHEUK[FSPRJ4[RM[WXQIQKFOXaHCE4UK[FSPRJ44WXUK[FSPRJL[JKLPX_RM[4C[RM[WXQIQKFOXaHQLDTSRZP4444[RM[WXQIQKFOXaHE4QLDTSRZP4WXQLDTSRZPL[JKLPX_RM[4C[RM[WXQIQKFOXaHe]RYUFMX4[RM[WXQIQKFOXaHcE4]RYUFMX4WX]RYUFMXL[JKLPX_RM[4C4C4WXUK[FSPRJBBQLDTSRZPBB]RYUFMXL[JKLPX_RM[4C4KGQLMSFVOZKGY	\aPMQJU
ZJFRSJPQN	QR4WXyrq|rmeaaM]XaV
\PIPNJK	Ra
cKGQLMSFVOZKL[JKLPKGQLMSFVOZK4L[JKLPOaGRKFGP[PGJ4C4WXGXG
[XY	_aR
D
Gyrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QRE4KGQLMSFVOZKGY	\aPMQJU
ZJFRSJPQN	QR4L[JKLPyrq|rmeaaM]XaV
\PIPNJK	Ra
cKGQLMSFVOZKKGQLMSFVOZKX_RM[4C4JLGE4~JQU[PaY[Ja_RRSJPQN	QRjqu{panlm{4L[JKLPJLK[4C]_J]VjVLQI_\R[Q	MNQOPFDE4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4L[JKLPX_RM[4C4C4444XKP]JWQPFaUJS
PXHWWQFN
\PSW4E4L[JKLP_LL_GXYTW[WWPHJQ_
RYN[aTSQUDQ

	RYN[aTSQUDQ

4C4XKP]JWQPGN_QT]\OPYOaDRP\WV4E4L[JKLP_LL_G_UMYGNJ\
XYTW[WWPHJQ_RYN[aTSQUDQ
D	]I_DOG_UMYGNJ\XYTW[WWPHJQ_
SF]
TFJDXYTW[WWPHJQ__UMYGNJ\	_UMYGNJ\SF]
TFJD_UMYGNJ\RYN[aTSQUDQ
IQ[
HR_D	]I_DOGSF]
TFJD
SF]
TFJDIQ[
HR_SF]
TFJD	RYN[aTSQUDQ
444C4XKP]JWQP[[VOJQTZOHXSGPTZ\4E44L[JKLP_LL_G_UMYGNJ\SF]
TFJD	RYN[aTSQUDQ
	XYTW[WWPHJQ_	4C44XKP]JWQPLQMN_N_SKUQUTa[KXXU[INGT
J]4E44WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	L[JKLPYD[P]QZ[XXU[INGT
J]44WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	
E4L[JKLPbFXbF\bFbFbFbFbFbFbFbFYDZ[XR_J[XXU[INGT
J]	yrq|rmeaaM]XaXSZRITaGaOLa	chyrq|rmeaaM]XaHH\P]DGF_MRMQa	cXXU[INGT
J]yrq|rmeaaM]XaXSZRITaGaOLa	chyrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]F]\\ZZ]F]

	4C4L[JKLPXXU[INGT
J]4C444XKP]JWQP[YaJUaKFDKPPXXU[INGT
J]44E4444WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]BByrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]L[JKLPXXU[INGT
J]4WXyrq|rmeaaM]Xa[NP\	U	acXXU[INGT
J]bFXbF\L[JKLPXXU[INGT
J]4WXyrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]
L[JKLPX_RM[4SW_ZSZVGXa~yrq|rmeaaM]XaQXZTaR[L
VQOa		chyrq|rmeaaM]Xa[NP\	U	acXXU[INGT
J]FF4SW_ZSZVGXayrq|rmeaaM]Xa]HYHVUa
cSW_ZSZVGXaSW_ZSZVGXaec4WXSW_ZSZVGXa
	BBSW_ZSZVGXa 		L[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	E4KSZ
H	MT
H~YDZ[]QZ[XXU[INGT
J]4WXKSZ
H	MT
HX_RM[L[JKLPKSZ
H	MT
H4C44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	E4KSZ
H	MT
H~YDWPXR_J[yrq|rmeaaM]Xa[NP\	U	acXXU[INGT
J]`yrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]

F
\F\
_[4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cKSZ
H	MT
Hyrq|rmeaaM]XaNJ]SSODDIGGaacKSZ
H	MT
H

	KSZ
H	MT
HX_RM[4C4L[JKLPX_RM[4C4XKP]JWQPWMS\SSOLXZDXVKMSVWRXDT\44E444WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLPyrq|rmeaaM]XaZY_R
WNVSINacVKMSVWRXDT\4WXyrq|rmeaaM]XaIMI

\G\\a
cVKMSVWRXDT\BByrq|rmeaaM]XaNJ]SSODDIGGaacVKMSVWRXDT\E4L[JKLPX_RM[444C4L[JKLPyrq|rmeaaM]XaXSZRITaGaOLa	cXYTW[WWPHJQ_VKMSVWRXDT\444C444XKP]JWQPZQYIVUTIDP[XTYXJ4E4P[UODSJUG	M[FX_LL_G4V[RHHJP_LL_G|mnjv|mnjvXYTW[WWPHJQ_|mnjvD	]I_DOG4WXZ[XWP[ZIQ[
HR_
V[RHHJPecina}qpj{pjazwl444XQL[_]VV[RHHJP_MKSZ
H	MT
HE4PORUXFG_G
Iyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

~yrq|rmeaaM]Xa\TOUSOOMFG\a	cKSZ
H	MT
HXYTW[WWPHJQ_X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cPORUXFG_G
IE4XQL[_]VPORUXFG_G
I_MJ]YVRPQ[aE4Iaa]O]SPU~yrq|rmeaaM]Xa_GRUDISIa	cJ]YVRPQ[a4WXIaa]O]SPUIaa]O]SPU FZ]\FX\_\E4P[UODSJUG	M[FXecIaa]O]SPU4C4C4C4C4WX[SNJGP[UODSJUG	M[FXE4G
SM	KLTZOJP[HP[UODSJUG	M[FXeyrq|rmeaaM]Xa[PS[FRLVacP[UODSJUG	M[FXc4L[JKLPG
SM	KLTZOJP[HG
SM	KLTZOJP[H
TJ_	QLHU	YJSMDSOF4444C4YJK		yrq|rmeaaM]XaD]SGTYaFPQHDac	4PMDXZ[XUyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	INaL_PZF_F

yrq|rmeaaM]Xa]XUTDWTUac	4G
SM	KLTZOJP[HYJK		PMDXZ[XU4L[JKLPG
SM	KLTZOJP[HG
SM	KLTZOJP[HTJ_	QLHU	YJSMDSOF44C4XKP]JWQPULHOKFLYNVMWMK	UHNK\RVa\SQ4E4WX[SNJGyrq|rmeRYN[aTSQUDQ
cL[JKLPHNK\RVa\SQ4YXH[NTQ][[ZDyrq|rmeIQ[
HR_cyrq|rmeaaM]XaZRTJRVaacJLK[4444WXYXH[NTQ][[ZDL[JKLPX_RM[44L[JKLPHNK\RVa\SQ YXH[NTQ][[ZDWPJyrq|rmeaaM]XaU	ZI\J
[D_acYXH[NTQ][[ZDHNK\RVa\SQ4C4XKP]JWQPGFX[HMRFF[RYYJFNPOZO]QQHNK\RVa\SQY
PaIPJGPKRR4E4HNK\RVa\SQULHOKFLYNVMWMK	UHNK\RVa\SQ4WXHNK\RVa\SQX_RM[L[JKLPX_RM[4444\IOIZ[FXG[
QMXKP]JWQPRMU[FaK]JNV_HKKM[Y
PaIPJGE4WXyrq|rmeaaM]XaIMI

\G\\a
cRMU[FaK]JNV_HKBBRMU[FaK]JNV_HKL[JKLPX_RM[44WXyrq|rmeaaM]XaNJ]SSODDIGGaacRMU[FaK]JNV_HK 



L[JKLPX_RM[444WXY
PaIPJGE4JLGE4L[JKLP\QQRyrq|rmeaaM]XaUQHVIIDGacY
PaIPJGRMU[FaK]JNV_HK44C]_J]VjVLQI_\R[Q	MNQOPFDE4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4L[JKLPX_RM[444C4C4L[JKLPJLK[4C4P]OWKL[WR[yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~yrq|rmeaaM]Xa\aLGRF
acJFNPOZO]QQ_LL_G4XYTW[WWPHJQ_
 HNK\RVa\SQ4D	]I_DOG X_RM[4D	]I_DOG 			44X_RM[4444WXP]OWKL[WR[yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	BBWMaINa[LLQLP]OWKL[WR[E4WXWPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[P]OWKL[WR[FF\	E44O]JN\YHLYVINaL[SQJ[aL[JLW[H[a\QZGP]OWKL[WR[44WX\IOIZ[FXG[
QMO]JN\YHLYVL[JKLPO]JN\YHLYV4C4C4HNK\RVa\SQULHOKFLYNVMWMK	UHNK\RVa\SQ4444WXHNK\RVa\SQX_RM[L[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4ZZ
KOODK]aR~yrq|rmeaaM]XaN]RPUKT\acJFNPOZO]QQ4WXZZ
KOODK]aRX_RM[L[JKLPX_RM[4~yrq|rmeaaM]XaI	NPMOO
QacZZ
KOODK]aR_LL_G4]QPMJ_PJSF]
TFJD JLK[4]QPMJ_PJRYN[aTSQUDQ
 HNK\RVa\SQ4]QPMJ_PJ_UMYGNJ\
 X_RM[4444]QPMJ_PJXYTW[WWPHJQ_ 4]QPMJ_PJD	]I_DOG X_RM[4]QPMJ_PJD	]I_DOG	 XKP]JWQPDODNOF_PN[NTPVHIQXaW\]G\VUI_aHIKVaE4L[JKLPUI_aHIKVa 

4C44RRaTQ_~yrq|rmeaaM]XaSIWa]PST[acZZ
KOODK]aR4P[MGHNV[P~]KLRa[LLPQZZ
KOODK]aR4LaFKUS
KaT[MV~]KLRaY[JWPXQZZ
KOODK]aR4~]KLRa]RQM[ZZ
KOODK]aR4WXP[MGHNV[PL[JKLPX_RM[4WXWPJLaFKUS
KaT[MVeSF]
TFJDc
RRaTQ_X_RM[\IOIZ[FXG[
QMRRaTQ_E444L[JKLPRRaTQ_4C4C4L[JKLPX_RM[4C44XKP]JWQP]PFYHWSD\XMT\RZLWZKJFNPOZO]QQZXUa	YXGKNFSRHH
JK
V][XHNK\RVa\SQY
PaIPJGPKRR4E4HNK\RVa\SQULHOKFLYNVMWMK	UHNK\RVa\SQ4WXHNK\RVa\SQX_RM[L[JKLPX_RM[4\IOIZ[FXG[
QMXKP]JWQPRMU[FaK]JNV_HKKM[Y
PaIPJGE4444WXyrq|rmeaaM]XaIMI

\G\\a
cRMU[FaK]JNV_HKBBRMU[FaK]JNV_HKL[JKLPX_RM[4WXyrq|rmeaaM]XaNJ]SSODDIGGaacRMU[FaK]JNV_HK 	L[JKLPX_RM[4WXY
PaIPJGE4JLGE4L[JKLP\QQRyrq|rmeaaM]XaUQHVIIDGacY
PaIPJGRMU[FaK]JNV_HK444C]_J]VjVLQI_\R[Q	MNQOPFDE4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4L[JKLPX_RM[4C4C4L[JKLPJLK[4C4P]OWKL[WR[yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~yrq|rmeaaM]XaJ_JJHSOXWYacJFNPOZO]QQ_LL_G4_UMYGNJ\
 HNK\RVa\SQ4RYN[aTSQUDQ
 X_RM[4SF]
TFJD F]
F[\[4SF]
TFJD NFSRHH
JK
V][X4XYTW[WWPHJQ_ ZXUa	YXGK4X_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	WMaINa[LLQLP]OWKL[WR[E4C[RM[WXP]OWKL[WR[E4SJPQN	QRWPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[P]OWKL[WR[4Z
L]RX]
INaL[SQJ[aL[JLW[H[a\QZGP]OWKL[WR[4DKOHINaL[SQJ[aL[JLW[H[aV[_Z[LMP]OWKL[WR[4KV
H
XLT_4WXyrq|rmeaaM]Xa]HYHVUa
cDKOHE4XQL[_]VDKOH_MI	ZLWVK_I [MZL
RLIF]WUE444KV
H
XLT_I	ZLWVK_IXYTW[WWPHJQ_[MZL
RLIF]WURYN[aTSQUDQ
4C4C4WXSJPQN	QRF
XF	\IOIZ[FXG[
QMZ
L]RX]
E4L[JKLPZ
L]RX]
4C4C[RM[E4C4WX[SNJGyrq|rmeXYTW[WWPHJQ_
cL[JKLPX_RM[4HNK\RVa\SQULHOKFLYNVMWMK	UHNK\RVa\SQ44WXHNK\RVa\SQX_RM[L[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\E4ZZ
KOODK]aR~yrq|rmeaaM]XaN]RPUKT\acJFNPOZO]QQ4WXZZ
KOODK]aRX_RM[E4L[JKLPX_RM[4C4XaWR_OKQZa_LL_G4XQL[_]VNFSRHH
JK
V][X_MI	ZLWVK_I [MZL
RLIF]WUE4XaWR_OKQZaecI	ZLWVK_ID	]I_DOG[MZL
RLIF]WU4C444~yrq|rmeaaM]XaI	NPMOO
QacZZ
KOODK]aR_LL_G444]QPMJ_PJRYN[aTSQUDQ
 JLK[4444]QPMJ_PJXYTW[WWPHJQ_ ZXUa	YXGK4]QPMJ_PJRYN[aTSQUDQ
 JLK[444]QPMJ_PJXYTW[WWPHJQ_ HNK\RVa\SQ44]QPMJ_PJIQ[
HR_
 X_RM[4]QPMJ_PJXYTW[WWPHJQ_ 4]QPMJ_PJXYTW[WWPHJQ_	 XaWR_OKQZa4]QPMJ_PJIQ[
HR_ X_RM[4]QPMJ_PJSF]
TFJD	 XKP]JWQPDODNOF_PN[NTPVHIQXaW\]G\VUI_aHIKVaE4L[JKLPUI_aHIKVa 
444C44RRaTQ_~yrq|rmeaaM]XaSIWa]PST[acZZ
KOODK]aR444P[MGHNV[P~]KLRa[LLPQZZ
KOODK]aR4HF[_\	GI\F[PHF~]KLRa[LLQLZZ
KOODK]aR4LaFKUS
KaT[MV~]KLRaY[JWPXQZZ
KOODK]aR4aO\F]GTWPJLaFKUS
KaT[MVeIQ[
HR_c44WXP[MGHNV[PE4~]KLRa]RQM[ZZ
KOODK]aR4444L[JKLPX_RM[4C444~]KLRa]RQM[ZZ
KOODK]aR4WXaO\F]GT		RRaTQ_X_RM[\IOIZ[FXG[
QMRRaTQ_E4L[JKLPRRaTQ_4C4WXRRaTQ_E4C44L[JKLPX_RM[4C4L[JKLPX_RM[4C44XKP]JWQPVTJFV
O	MUVIR[XLPVZMJQ
4E4XYLLLKa[QTPHFaUJS
PXHWWQFN
\PSW4NFVMUSNUXOVGN_QT]\OPYOaDRP\WV4IR[XLPVZMJQWPJIR[XLPVZMJQ444WXIR[XLPVZMJQFFIR[XLPVZMJQ
4WXIR[XLPVZMJQ IR[XLPVZMJQ	`
44WX[SNJGXYLLLKa[QTPHBB[SNJGNFVMUSNUXOVE4L[JKLP_LL_G4C44VaJDJ[HIDYUyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG

MJLWPYY[JaQNJWQPXYTW[WWPHJQ_44WXVaJDJ[HIDYUyrq|rmeaaM]Xa_LHMQPFPD
Ma
cVaJDJ[HIDYUNFVMUSNUXOVJLK[VaJDJ[HIDYU4WXVaJDJ[HIDYUE4NFVMUSNUXOVyrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaaVYPVSS
acNFVMUSNUXOV_LL_GVaJDJ[HIDYU4yrq|rmeaaM]XaLQG\RONGGRXWacNFVMUSNUXOVVaJDJ[HIDYU44C44GV\VVQNXyrq|rmeaaM]XaVMQGFWM]acXYLLLKa[QTPHeyrq|rmeaaM]Xa[PS[FRLVacXYLLLKa[QTPHc4WXGV\VVQNXE44L[JKLP_LL_G4C44ZXUa	YXGKXYTW[WWPHJQ_GV\VVQNX_UMYGNJ\4YWOaQSKXO_LL_GSF]
TFJD
 IQ[
HR_4SWXLFTH_aHyrq|rmeaaM]XaZRTJRVaacJLK[4XQL[_]VNFVMUSNUXOV_MRP
LINVQ_[OPOE44444WXyrq|rmeaaM]XaZRTJRVaacJLK[SWXLFTH_aH IR[XLPVZMJQE4\L[_U4C44RP
LINVQ_[OPOyrq|rmeaaM]XaVMQGFWM]acMJLWPYRP
LINVQ_[OPO4WXRP
LINVQ_[OPOE4]QPJWPK[4C4JLGE4Z
L]RX]
]PFYHWSD\XMT\RZLWZKRP
LINVQ_[OPOZXUa	YXGKYWOaQSKXO	`XKP]JWQPRMU[FaK]JNV_HKE4P_FD
PW
QJO~yrq|rmeaaM]Xa]FQGV	\SacRMU[FaK]JNV_HKJLK[4L[JKLPyrq|rmeaaM]Xa]HYHVUa
cP_FD
PW
QJOWMM[JP_FD
PW
QJOeSF]
TFJD	c444C4WXZ
L]RX]
X_RM[E4]QPJWPK[4C4_HTJJHYG~yrq|rmeaaM]Xa]FQGV	\SacZ
L]RX]
JLK[4WXyrq|rmeaaM]Xa]HYHVUa
c_HTJJHYGBBWMM[J_HTJJHYGeXYTW[WWPHJQ_cBByrq|rmeaaM]XaIMI

\G\\a
c_HTJJHYGe_UMYGNJ\cE4]QPJWPK[44C44VKMSVWRXDT\_HTJJHYGeRYN[aTSQUDQ
c4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cVKMSVWRXDT\D	]I_DOGE4444VKMSVWRXDT\yrq|rmeaaM]Xa[NP\	U	acVKMSVWRXDT\4C44UIIMH[OV~WMS\SSOLXZDXVKMSVWRXDT\4WXUIIMH[OVX_RM[BByrq|rmeaaM]XaNJ]SSODDIGGaacUIIMH[OV
`E4]QPJWPK[4C4444QDYOOHGRGJD	
444aV	PGFTQOFayrq|rmeaaM]Xa[QXFPSWILaQacUIIMH[OVeQDYOOHGRGJDc4UNPXHJ]Lyrq|rmeaaM]Xa[NP\	U	acUIIMH[OVQDYOOHGRGJDaV	PGFTQOFa4WXyrq|rmeaaM]XaIMI

\G\\a
cUNPXHJ]LBByrq|rmeaaM]XaNJ]SSODDIGGaacUNPXHJ]LE4]QPJWPK[4C44444SQN]]DJyrq|rmeaaM]Xa[QXFPSWILaQacUNPXHJ]Lec4WXSQN]]DJBByrq|rmeaaM]XaNJ]SSODDIGGaacUNPXHJ]LSQN]]DJE4]QPJWPK[4444C44WW\WUJKFPVGOLYyrq|rmeaaM]Xa[NP\	U	acUNPXHJ]LSQN]]DJ4ZLFNK		MZaNSNGyrq|rmeaaM]Xa[NP\	U	acUNPXHJ]LSQN]]DJ4WXyrq|rmeaaM]XaIMI

\G\\a
cWW\WUJKFPVGOLYBByrq|rmeaaM]XaIMI

\G\\a
cZLFNK		MZaNSNGE4]QPJWPK[4C444444IKKK[UXZYXWLRYDITOJZLFNK		MZaNSNGWW\WUJKFPVGOLY4WXyrq|rmeaaM]XaIMI

\G\\a
cIKKK[UBByrq|rmeaaM]XaNJ]SSODDIGGaacIKKK[UE4444QWVIDDHOPHQ[VKZMIQ[
HR_SF]
TFJD
4]QPJWPK[4444C44WUY_GR_RVQLyrq|rmeaaM]Xa[QXFPSWILaQacIKKK[Uec4WXWUY_GR_RVQLBByrq|rmeaaM]XaNJ]SSODDIGGaacIKKK[UWUY_GR_RVQLE4QWVIDDHOPHQ[VKZMIQ[
HR_SF]
TFJD4]QPJWPK[4C44444D	VD[]LG]Tyrq|rmeaaM]Xa[NP\	U	acIKKK[UWUY_GR_RVQL4SS_
NK_UJMS[yrq|rmeaaM]Xa[NP\	U	acIKKK[UWUY_GR_RVQL4PaGP
]J	yrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaV[RJJX\MN
acyrq|rmeaaM]XaOP\[VSWFHacXYTW[WWPHJQ_yrq|rmeaaM]XaXRMONPW[a	cXYTW[WWPHJQ_SS_
NK_UJMS[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4KNZ_J[aQNJWQP_UMYGNJ\RP
LINVQ_[OPO4KNZ_J[aQNJWQPXYTW[WWPHJQ_yrq|rmeaaM]XaZ
ZVRO
UNLDKa
cbPPaGP
]J	4C4444L[JKLP_LL_GD	]I_DOG
 D	VD[]LG]TRYN[aTSQUDQ

 PaGP
]J	4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4]QPJWPK[4C]_J]V{F][NJWQPQ	MNQOPFDE4]QPJWPK[4C4C4T
JI\SGO	Qyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ


MJLWPYY[JaQNJWQP_UMYGNJ\4MP	][ZMYL_	GUOJ[XOIWQ_UMYGNJ\
4WXT
JI\SGO	Qyrq|rmeaaM]XaIMI

\G\\a
cMP	][ZMYL_	MP	][ZMYL_	E4PaGP
]J	yrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaV[RJJX\MN
acyrq|rmeaaM]XaOP\[VSWFHacSF]
TFJD

yrq|rmeaaM]XaXRMONPW[a	cXYTW[WWPHJQ_
T
JI\SGO	Q4WX[SNJGPaGP
]J	E4L[JKLP_LL_GXYTW[WWPHJQ_
 MP	][ZMYL_	SF]
TFJD
 PaGP
]J	4C4C4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_
D	]I_DOG
	4L[JKLP_LL_G4C4XKP]JWQPN_IR_L_NTa[RUX	OTZOF[	ZGQRDNJIDHLLFITQ\XWN4E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4L[JKLPX_RM[4C444WXWMM[Jyrq|rmeD	]I_DOG
cyrq|rmeaaM]Xa]HYHVUa
cyrq|rmeSF]
TFJDcyrq|rmeaaM]Xa\[X\\K[PFa
cUX	OTZOF[	Zyrq|rmeRYN[aTSQUDQ
cE4KPM[Jyrq|rme_UMYGNJ\ceUX	OTZOF[	Zc44C44TLRJLFQGaU[Tyrq|rmeaaM]XaYQMWZU	ZQPacGQRDNJI4I\UPKDMFUSNyrq|rmeaaM]XaS]ZINNJ_acyrq|rmeaaM]XaFL_RINU
a
c`	4PZSGFJRM[O4444XQLLTZU
DL\H]UTZK]OUFLyrq|rmeaaM]XaNJ]SSODDIGGaacTLRJLFQGaU[TLTZU
DL\H]UTZK]OUFLLTZU
DL\HE4PZSGFJRM[Oyrq|rmeaaM]XaS]ZINNJ_acyrq|rmeaaM]Xa[QXFPSWILaQacTLRJLFQGaU[TeLTZU
DL\Hc`yrq|rmeaaM]Xa[QXFPSWILaQacI\UPKDMFUSN4C4L[JKLPKNZ_J[aQNJWQPUX	OTZOF[	Zyrq|rmeaaM]Xa\	V]W	QFacI\UPKDMFUSNPZSGFJRM[ODHLLFITQ\XWNX_RM[4C44XKP]JWQPHDMHD
OJRSLDGYHUX	OTZOF[	ZXT][OOXLV\\PRI44E4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

L[JKLPXT][OOXLV\\PRI4WXWMM[Jyrq|rmeIQ[
HR_cyrq|rmeaaM]Xa]HYHVUa
cyrq|rme_UMYGNJ\cyrq|rmeaaM]Xa\[X\\K[PFa
cUX	OTZOF[	Zyrq|rmeXYTW[WWPHJQ_cE4L[JKLPyrq|rmeIQ[
HR_ceUX	OTZOF[	Zc4C4R
\I
NaNZY[JaQNJWQPUX	OTZOF[	Z4WXR
\I
NaNZBByrq|rmeaaM]XaIMI

\G\\a
cR
\I
NaNZE4444L[JKLPXT][OOXLV\\PRI4C4WU[X\U_DWW	~yrq|rmeaaM]Xa]HN[Q	\\KPOVacR
\I
NaNZJLK[4WXWU[X\U_DWW	X_RM[BByrq|rmeaaM]XaNJ]SSODDIGGaacWU[X\U_DWW	E4L[JKLPXT][OOXLV\\PRI4C4I\UPKDMFUSNWU[X\U_DWW	ec4PYG]WJYQF4XQLLTZU
DL\H]UTZK]OUFLyrq|rmeaaM]XaNJ]SSODDIGGaacWU[X\U_DWW	LTZU
DL\H]UTZK]OUFLLTZU
DL\HE4PYG]WJYQFyrq|rmeaaM]XaS]ZINNJ_acyrq|rmeaaM]Xa[QXFPSWILaQacWU[X\U_DWW	eLTZU
DL\Hc`yrq|rmeaaM]Xa[QXFPSWILaQacI\UPKDMFUSN4C4NVZ_MFNX
H[LJQS\YQ_YL\JPYG]WJYQF4WXNVZ_MFNX
X_RM[E4444WXWMM[Jyrq|rmeD	]I_DOG	cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeIQ[
HR_	cyrq|rme_UMYGNJ\	c_LL_G4WXyrq|rmeaaM]XaOG\FSVKacyrq|rmeXYTW[WWPHJQ_	c yrq|rmeXYTW[WWPHJQ_c_LL_G4yrq|rme_UMYGNJ\ceUX	OTZOF[	ZcNVZ_MFNX
4L[JKLPNVZ_MFNX
44C4L[JKLPXT][OOXLV\\PRI4C4444XKP]JWQPH[LJQS\YQ_YL\JUNPXHJ]L4E4WXyrq|rmeaaM]XaIMI

\G\\a
cUNPXHJ]LL[JKLPX_RM[4WXZ[XWP[Z_UMYGNJ\nvnah{lmwqpawz 
E4L[JKLP~yrq|rmeaaM]XaKODUaRWJ]
acUNPXHJ]L_LL_GIQ[
HR_ X_RM[4444C4L[JKLP~yrq|rmeaaM]XaKODUaRWJ]
acUNPXHJ]L4C4XKP]JWQPFDWGTG]GOQZ4E4MJ_JW]I	ZLWVK_IPKRR4WXI	ZLWVK_IPKRRL[JKLPI	ZLWVK_I4F_aLRUKPPPL[Z[XWP[ZIQ[
HR_|mnjv4I	ZLWVK_Iyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]XaXUWXXXT
OYacbbF_aLRUKPPPL[4L[JKLPI	ZLWVK_I4C44XKP]JWQPLF[]P
	ON
Z
UX	OTZOF[	Z4E4L[JKLPYFJN
WLK\PFDWGTG]GOQZMJLWPYTJ_	QLHU	YJSMDSOFUX	OTZOF[	Z4444C4XKP]JWQPDH_PZM_SHORILPNDPMIPMH444E4L[JKLPMJLWPY	WPJV[FZ[]yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacFDWGTG]GOQZRYN[aTSQUDQ
LPNDPMIPMH
444C4XKP]JWQPOQDY	HVZXHJRTUQ]KQP4E4L[JKLPDH_PZM_SHORI_UMYGNJ\
4C4XKP]JWQPFJZRF	_	WXSP4E4WXKROP	L\MJLWPYGUOJ[XOIWQIQ[
HR_44L[JKLPyrq|rmeaaM]XaNJ]SSODDIGGaacWXKROP	L\ F
Fyrq|rmeaaM]Xa_K_QN_\W	a]a	cWXKROP	L\OQDY	HVZXHJRTUQ]KQPX_RM[yrq|rmeaaM]XaNJ]SSODDIGGaacMJLWPYGUOJ[XOIWQSF]
TFJD 4C44XKP]JWQPGUOJ[XOIWQUX	OTZOF[	ZXT][OOXLV\\PRI4E44L[JKLPHDMHD
OJRSLDGYHLF[]P
	ON
Z
UX	OTZOF[	ZXT][OOXLV\\PRI4C4XKP]JWQPaZTNULYVSS
]UX	OTZOF[	ZXT][OOXLV\\PRI4E4444[MZL
RLIF]WUGUOJ[XOIWQUX	OTZOF[	ZXT][OOXLV\\PRI4WXyrq|rmeaaM]XaIMI

\G\\a
c[MZL
RLIF]WUL[JKLP[MZL
RLIF]WU4WXyrq|rmeaaM]XaS_QNWZRIWG[a	c[MZL
RLIF]WUL[JKLPMJLWPY[MZL
RLIF]WU4L[JKLPXT][OOXLV\\PRI44C44XKP]JWQPSY	]ZUMDJLRRUX	OTZOF[	ZGQRDNJIDHLLFITQ\XWN4E4L[JKLPN_IR_L_NTa[RLF[]P
	ON
Z
UX	OTZOF[	ZGQRDNJIDHLLFITQ\XWN4C4XKP]JWQP\RQTIHWHKDHNYLH[RD4E4a__D	]ULPWMM[Jyrq|rmeIQ[
HR_cyrq|rmeRYN[aTSQUDQ
c_LL_G4R
\I
NaNZGUOJ[XOIWQ_UMYGNJ\_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cR
\I
NaNZE4a__D	]ULPyrq|rmeaaM]XaZOVZW
]WRZLLKa	cR
\I
NaNZa__D	]ULP4C4a__D	]ULPyrq|rmeaaM]XaUYGQMULaFLa
ca__D	]ULP4444L[JKLPyrq|rmeaaM]XaRSVOIDaFHTJaca__D	]ULPFXF4C4444XKP]JWQPMJKZY
GIN\[SFTFZMRZ4444E4WXWMM[Jyrq|rmeXYTW[WWPHJQ_	cBB[SNJGyrq|rmeD	]I_DOG	cL[JKLP4JLGE4R
\I
NaNZGUOJ[XOIWQSF]
TFJD_LL_G444KTKaRFUVRGyrq|rmeaaM]XaUYGQMULaFLa
cyrq|rmeaaM]XaZOVZW
]WRZLLKa	c_LL_GR
\I
NaNZyrq|rmeSF]
TFJD	c4KTKaRFUVRGyrq|rmeaaM]XaRSVOIDaFHTJacKTKaRFUVRG4SY	]ZUMDJLRRIQ[
HR_KTKaRFUVRGXYTW[WWPHJQ_	4444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	Q	MNQOPFD44C]_J]V{F][NJWQPQ	MNQOPFDE4C4C44XKP]JWQPXZYXWLRYDITOJUNPXHJ]LU[G4E4WXyrq|rmeaaM]XaIMI

\G\\a
cUNPXHJ]LBByrq|rmeaaM]XaIMI

\G\\a
cU[GBByrq|rmeaaM]XaNJ]SSODDIGGaacU[GE4L[JKLPPKRR4C4FUI		]\yrq|rmeaaM]XaNJ]SSODDIGGaacUNPXHJ]L4KQHRYDV
[Jyrq|rmeaaM]XaNJ]SSODDIGGaacU[G444VGaX
KNKaFQY4XQLLTZU
DL\HLTZU
DL\HFUI		]\LTZU
DL\HE4VGaX
KNKaFQYyrq|rmeaaM]XaS]ZINNJ_acyrq|rmeaaM]Xa[QXFPSWILaQacUNPXHJ]LeLTZU
DL\Hc`yrq|rmeaaM]Xa[QXFPSWILaQacU[GeLTZU
DL\HKQHRYDV
[Jc4C4L[JKLPVGaX
KNKaFQY4C4444XKP]JWQPUQaH
WPNH_N[\K_LDWVFKLGKDK]4E4WXyrq|rmeaaM]Xa]HYHVUa
c_LDWVFKLGKDK]E4_LDWVFKLGKDK]_LL_G4C4MJ_JW]PIURRL[S[HPKRR4WXPIURRL[S[HPKRRE4PIURRL[S[HRXJYHGLQV	JRX44V_TF
KQL_HSRSyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

HDMHD
OJRSLDGYHD	]I_DOG	X_RM[X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cV_TF
KQL_HSRSWMM[JV_TF
KQL_HSRSeRYN[aTSQUDQ
	
cWPJV_TF
KQL_HSRSeIQ[
HR_	
c 
WPJV_TF
KQL_HSRSeD	]I_DOG	
cPIURRL[S[HWPJV_TF
KQL_HSRSeXYTW[WWPHJQ_	
c4WXPIURRL[S[HFF	E4PIURRL[S[H	
4C4C4_LDWVFKLGKDK]eIQ[
HR_	c_LL_G4XYTW[WWPHJQ_	 PIURRL[S[H4444RYN[aTSQUDQ
		 D	]I_DOG	44_LDWVFKLGKDK]eIQ[
HR_	c_LL_G4RYN[aTSQUDQ
	 	4D	]I_DOG		 RYN[aTSQUDQ
44444L[JKLP_LDWVFKLGKDK]4C44XKP]JWQPX]U\HNNZZQWOGO4E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLP4WXZPO_XHQ_]L_ZIQ[
HR_L[JKLP4JLGE44WXINaP[FJaM]V[ZKR[ZSWHLLXDFJUGMKTE44INaM]V[ZKR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDacyrq|rmeaaM]XaFL_RINU
a
cFF
FFRYN[aTSQUDQ
	SWHLLXDFJUGMKT444C4CXWP_RRGE4444FT_Q_YTVaGTIQ[
HR_4C444C444444XKP]JWQPHWWPPSPX]\NSIXVKS4E44WXZ[XWP[ZD	]I_DOG
zqwpya}lqpE4L[JKLP4C44MJ_JW]XSIN	WaII	YD_X_RM[4WXXSIN	WaII	YD_L[JKLP4XSIN	WaII	YD_JLK[44WXDIOSNLSY_aLH_LRM_SE4L[JKLP4C444\GXT\HI_L]RNSF]
TFJDRYN[aTSQUDQ
4C4XKP]JWQPZII_VHXTWZSMJa_4E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLP444~yrq|rmeaaM]Xa\aLGRF
acMWJ[aKLRIQ[
HR_yrq|rmeaaM]XaXUWXXXT
OYacMJLWPYyrq|rmeaaM]XaZRTJRVaacJLK[yrq|rmeaaM]XaFL_RINU
a
cF	FZF
XF_LL_GIQ[
HR_ RYN[aTSQUDQ
 X_RM[RYN[aTSQUDQ
 X_RM[4C4XKP]JWQPP_NTGWP]Q
_\M4E4MJ_JW]YDH_XaWWDKFX_RM[4WXYDH_XaWWDKFL[JKLP4YDH_XaWWDKFJLK[4JLGE44LP_a\DKMKYF]ZLTR__444ORKUMaTX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E4yrq|rmeaaM]XaPT[N\H_\U	LXac4ORKUMaTJLK[4C[RM[WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4yrq|rmeaaM]XaTWRSTN
\YG
\a
c444ORKUMaTJLK[444C[RM[E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4~yrq|rmeaaM]XaMHSN\]HKXIacJLK[4C4KRKNXZY\X_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4YIaIJNMDMIyrq|rmeaaM]XaRJLRacyrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]Xa[PD\GWFacD	]I_DOG	4KRKNXZY\YIaIJNMDMIYIaIJNMDMIYIaIJNMDMIIQ[
HR_4C4KV]YGLQOIyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~Q\aY[JaMJ_JKMJLK[_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cKV]YGLQOIE4XQL[_]VKV]YGLQOI_MXNW	WHKRQL
E4SWXaG
KRPOyrq|rmeaaM]Xa]HYHVUa
cXNW	WHKRQL
WMM[JXNW	WHKRQL
eSF]
TFJD
cyrq|rmeaaM]XaRJLRacMJLWPYXNW	WHKRQL
eIQ[
HR_
c4444WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cSWXaG
KRPOD	]I_DOG
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cSWXaG
KRPOD	]I_DOG
X_RM[E4KRKNXZY\JLK[4\L[_U4C4C4C4WXKRKNXZY\yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4XQL[_]V_LL_G~V[_Z[LMaRWMJ_M_ZLNNIOLQOH[E4WXMJLWNQM_ZLNNIOLQOH[D	]I_DOG

MJLWNQM_ZLNNIOLQOH[_UMYGNJ\
X_RM[E4KRKNXZY\JLK[4\L[_U4444C444C4444C4G[MTO]SDyrq|rmeaaM]XaFOMVMVNG[KNac4T	IF\]DDVG[MTO]SDIQ[
HR_
G[MTO]SDXYTW[WWPHJQ_
	4OZO[OTN]ayrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
WPJ~VJJNaL[MNQPM[a]QZ[4USVUKNY]_OZO[OTN]a FFOZO[OTN]aFZF_\BBOZO[OTN]aF

FBBOZO[OTN]a
4]\FFTTI]Pa\UWMM[Jam{lh{leD	]I_DOG
cam{lh{le_UMYGNJ\
cRYN[aTSQUDQ

4HQDRNL\MH
XX_RM[4WXT	IF\]DDVUSVUKNY]_]\FFTTI]Pa\UV[_Z[LMaM[PJKRKNXZY\E4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c E4[TOMFNZW]P_yrq|rmeaaM]XaVTN_HLNZS_Na
c444WX~yrq|rmeaaM]XaUKVQJ]YK\a
cBByrq|rmeaaM]XaVTN_HLNZS_Na
c [TOMFNZW]P_\L[_U4444C4XNW	WHKRQL
yrq|rmeaaM]XaVTN_HLNZS_Na
cyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~Q\aY[JaMJ_JKM_LL_G444SWXaG
KRPOyrq|rmeaaM]Xa]HYHVUa
cXNW	WHKRQL
WMM[JXNW	WHKRQL
eIQ[
HR_
cyrq|rmeaaM]XaRJLRacMJLWPYXNW	WHKRQL
eRYN[aTSQUDQ

c4a]RX_RM[4WXyrq|rmeaaM]XaVTN_HLNZS_Na
cE4a]R4C[RM[WX4yrq|rmeaaM]XaVTN_HLNZS_Na
c4yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG4444SWXaG
KRPOBBSWXaG
KRPO_UMYGNJ\

4yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
4E4a]R~Q\aY[JaR[PYJV4C4QG[\\NTIYJLK[4WXWMM[Jyrq|rmeIQ[
HR_
ce_UMYGNJ\
	cE4aIXyrq|rmeXYTW[WWPHJQ_
ceSF]
TFJD
	c4JOS]M	QXPUP_yrq|rmeaaM]XaJFVY[	SJPKa	caIXWMM[JaIX ]_RR\_]UMaIX ]_RR\_]UMyrq|rmeaaM]Xa]HYHVUa
caIXaIX_LL_G4XQL[_]VJOS]M	QXPUP__MaNL ]aDFJLT	NGRD\E4WXyrq|rmeaaM]Xa]HYHVUa
c]aDFJLT	NGRD\]QPJWPK[4444XQL[_]V]aDFJLT	NGRD\_MVVT]DILME4NWPIGUKXyrq|rmeaaM]Xa]HYHVUa
cVVT]DILMWMM[JVVT]DILMeD	]I_DOG
cVVT]DILMeSF]
TFJD
c44WXyrq|rmeaaM]XaIMI

\G\\a
cNWPIGUKXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cNWPIGUKX_LL_GRYN[aTSQUDQ
RYN[aTSQUDQ

JLK[]QPJWPK[4QG[\\NTIYX_RM[4444\L[_U4C4C4KPM[JaIXJOS]M	QXPUP_aNL]aDFJLT	NGRD\VVT]DILMNWPIGUKX4C44WXa]RX_RM[QG[\\NTIYV[_Z[LMaM[PJE4~V[_Z[LIQ[
HR_
WPJa]R4~V[_Z[L_UMYGNJ\
4HQDRNL\MH
XJLK[4C4C4WXT	IF\]DDVE4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c E4444[TOMFNZW]P_yrq|rmeaaM]XaVTN_HLNZS_Na
c4WX~yrq|rmeaaM]XaUKVQJ]YK\a
cBByrq|rmeaaM]XaVTN_HLNZS_Na
c [TOMFNZW]P_\L[_U4C4~yrq|rmeaaM]XaM_[SORX\[Va
c4C4WXHQDRNL\MH
Xyrq|rmeaaM]XaVTN_HLNZS_Na
cORKUMaTJLK[4KPM[JKRKNXZY\YIaIJNMDMIKV]YGLQOIXNW	WHKRQL
SWXaG
KRPO_ZLNNIOLQOH[G[MTO]SDT	IF\]DDVOZO[OTN]aUSVUKNY]_HQDRNL\MH
X[TOMFNZW]P_a]R]\FFTTI]Pa\U4C4_TFKRLZUUKGyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

Z[XWP[Z_UMYGNJ\
zwm|r{aina}lqp444GJMFJMJOMyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

BBWPJY[JaQNJWQP_UMYGNJ\
4WXGJMFJMJOMyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
E4HN_HRT[MJLWPYY[JaQNJWQPIQ[
HR_
	4WXHN_HRT[RINYW\WDWV_QNR
I	E4~KNZ_J[aQNJWQPSF]
TFJD
	RINYW\WDWV_QNR
I	D	]I_DOG	4~KNZ_J[aQNJWQPIQ[
HR_
IQ[
HR_
4GJMFJMJOMJLK[4C4C4QS]KOOVFN	X_RM[4444WX_TFKRLZUUKGyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E4SDQUXLMUKXINaP[FJaM]V[ZKR[ZSWHLLXDFJUGMKT4WXSDQUXLMUKXyrq|rmeaaM]XaD]SGTYaFPQHDacWPJSDQUXLMUKX 	E4QS]KOOVFN	JLK[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~INaKPM]V[ZKR[a[H[PJWPJSDQUXLMUKXSWHLLXDFJUGMKT4C4C4WX_TFKRLZUUKGGJMFJMJOMQS]KOOVFN	E4XGTGVK
yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_WPJINaP[FJaM]V[ZKR[ZSWHLLXDFJUGMKT4WXXGTGVK
BBXGTGVK
yrq|rmeaaM]XaD]SGTYaFPQHDac 
	E4~INaM]V[ZKR[aMWPYR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDacSWHLLXDFJUGMKT4C4DVWPNRD
aXZG4L[JKLP444C44WXQS]KOOVFN	QWVIDDHOPHQ[VKZMIQ[
HR_
RYN[aTSQUDQ

4WXORKUMaTE444WX_TFKRLZUUKGE4~INaM]V[ZKR[aMWPYR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDacSWHLLXDFJUGMKT44ZII_VHXTWZSMJa_4DVWPNRD
aXZG4L[JKLP4C4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~yrq|rmeaaM]XaX	UM	IQQaVa
c4444PHD	Q]LNLV	4L[JKLP4C4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
~yrq|rmeaaM]XaX	UM	IQQaVa
c

4PHD	Q]LNLV4C]_J]VjVLQI_\R[Q	MNQOPFDE444QWVIDDHOPHQ[VKZMSF]
TFJD
	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C444C44XKP]JWQPVDTZIUJNFXQLH	L[MF4E4444JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

E4L[JKLP4C44444VUHLL[RQX]PDMaWyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
Y[JaJL_PMW[PJNZKPMO\X[I[UX_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cVUHLL[RQX]PDMaWVUHLL[RQX]PDMaWHDMHD
OJRSLDGYHD	]I_DOG	X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cVUHLL[RQX]PDMaWE4L[JKLP4C44WXWMM[JVUHLL[RQX]PDMaWeXYTW[WWPHJQ_
cyrq|rmeaaM]Xa]HYHVUa
cVUHLL[RQX]PDMaWeRYN[aTSQUDQ

cE4yrq|rme_UMYGNJ\
	cVLTKTV
SL_KGKFGWWVUHLL[RQX]PDMaWeSF]
TFJD
c4C44WXWMM[JVUHLL[RQX]PDMaWeXYTW[WWPHJQ_
cyrq|rmeaaM]Xa]HYHVUa
cVUHLL[RQX]PDMaWeSF]
TFJD
cE4yrq|rmeRYN[aTSQUDQ

cVLTKTV
SL_KGKFGWWVUHLL[RQX]PDMaWeRYN[aTSQUDQ


c4444C444WXWMM[JVUHLL[RQX]PDMaWeXYTW[WWPHJQ_

cyrq|rmeaaM]XaIMI

\G\\a
cVUHLL[RQX]PDMaWeIQ[
HR_

cE4yrq|rmeSF]
TFJD

cVUHLL[RQX]PDMaWeXYTW[WWPHJQ_

c4C4WXWMM[JVUHLL[RQX]PDMaWeSF]
TFJD

cyrq|rmeaaM]XaIMI

\G\\a
cVUHLL[RQX]PDMaWeIQ[
HR_

cyrq|rmeaaM]XaNJ]SSODDIGGaacVUHLL[RQX]PDMaWeSF]
TFJD

c F]FE4yrq|rmeXYTW[WWPHJQ_


cVUHLL[RQX]PDMaWeRYN[aTSQUDQ


c4C4WXWMM[JVUHLL[RQX]PDMaWeSF]
TFJD

cyrq|rmeaaM]XaIMI

\G\\a
cVUHLL[RQX]PDMaWeIQ[
HR_

cyrq|rmeaaM]XaNJ]SSODDIGGaacVUHLL[RQX]PDMaWeIQ[
HR_

c E4yrq|rmeIQ[
HR_

cVUHLL[RQX]PDMaWe_UMYGNJ\

	c4C4444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMIQ[
HR_

Q	MNQOPFD44C]_J]V{F][NJWQPQ	MNQOPFDE4C4444C44444XKP]JWQP[OKNGPJSRH	aLPXLJ\4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\

BByrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
L[JKLP4WXWPJY[JaQNJWQPRYN[aTSQUDQ

 yrq|rmeaaM]XaD]SGTYaFPQHDacL[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

Y[JaJL_PMW[PJIQ[
HR_
L[JKLP4WXFKWUXVGDYVWZLL[JKLP4LZ
PXSFMRJHXGUOJ[XOIWQRYN[aTSQUDQ

4WXyrq|rmeaaM]XaIMI

\G\\a
cLZ
PXSFMRJHXBByrq|rmeaaM]XaNJ]SSODDIGGaacLZ
PXSFMRJHXF	FZBBRKHMW]\JKFVLZ
PXSFMRJHXBBGQS[a	
DD\SGLHVLZ
PXSFMRJHXE4LZ
PXSFMRJHXX_RM[444__O[SLSJDYLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
c__O[SLSJDRKHMW]\JKFV__O[SLSJDGQS[a	
DD\SGLHV__O[SLSJDE444SY	]ZUMDJLRRD	]I_DOG
__O[SLSJDXYTW[WWPHJQ_
4LZ
PXSFMRJHX__O[SLSJD4C4WXLZ
PXSFMRJHXE4~KNZ_J[aQNJWQPD	]I_DOG
yrq|rmeaaM]XaD]SGTYaFPQHDacIQ[
HR_
4L[JKLP444C4C4WPYJORFYS_LL_GXTDWYLRT_NPTYMLP44HXG_NW]N	\PQQYLWZWNM]_KP4FRVT_]	]NS[VXJQLP]KURFMDRXHXG_NW]N	

	444WXyrq|rmeaaM]Xa]HYHVUa
cFRVT_]	]NS[VXJE444XQL[_]VFRVT_]	]NS[VXJ_MGLaSFK[\]aDaE4WXyrq|rmeaaM]Xa[NP\	U	acGLaSFK[\]aDaSF]
TFJD

WPYJORFYSecHXG_NW]N	GLaSFK[\]aDa444C4C4WXZ[XWP[Z_UMYGNJ\yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4444XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cinanrkywpazwlSF]
TFJD
_MGJY\]JMUFHWPYJORFYSecGJY\]JMUFH4C44WPYJORFYSyrq|rmeaaM]XaUYGQMULaFLa
cWPYJORFYS4QUN	JXWNZL_LL_G44]XKQJY	LVPZYHyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJD
	yrq|rmeaaM]Xa[NP\	U	acLZ
PXSFMRJHX
			4XQL[_]VWPYJORFYS_MF_aLRUKPPPL[E4ZMKUD
~yrq|rmeaaM]XaNDD_U_S]R\\acF_aLRUKPPPL[4WXZMKUD
BBZMKUD


]QPJWPK[4444NF\DRQKVHR~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[X_RM[PKRR

4WXyrq|rmeaaM]XaIMI

\G\\a
cNF\DRQKVHRBBRKHMW]\JKFVNF\DRQKVHR]QPJWPK[444WXF_aLRUKPPPL[XTDWYLRT_NPTYMLPyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ

	NF\DRQKVHR]XKQJY	LVPZYH]QPJWPK[4QUN	JXWNZLecF_aLRUKPPPL[4C4WXQUN	JXWNZLE4~KNZ_J[aQNJWQPXYTW[WWPHJQ_
yrq|rmeaaM]XaD]SGTYaFPQHDacD	]I_DOG
44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDM[JaJL_PMW[PJD	]I_DOG


4L[JKLP4C4~KNZ_J[aQNJWQPRYN[aTSQUDQ

yrq|rmeaaM]XaD]SGTYaFPQHDacIQ[
HR_
4XQL[_]VQUN	JXWNZL_MJ]YVRPQ[aE4Y_HVRRKFFH]X
]VL
RJ]YVRPQ[a
4WXTO[]UPZVQVUTYTJ]YVRPQ[aG\VSaUWFRZGLZ
PXSFMRJHXE4Q_XFKXa_[MVSZ	J]YVRPQ[a4I_HUSY[\MMDZQUHJ]YVRPQ[a4Y_HVRRKFFH]X
]VL
RJ]YVRPQ[a
4Xa\
Qa\
N_TUJ]YVRPQ[a4444WXJ]YVRPQ[aXTDWYLRT_NPTYMLPE4PJYY\WJKRYWPPSJLK[4]_TSGKYNR	aUMMJLK[4C44C[RM[E4Y_HVRRKFFH]X
]VL
RJ]YVRPQ[a	4C444C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMIQ[
HR_
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPOWI[F\UGXNDXL4E4MJ_JW]XSIN	WaII	YD_X_RM[4WXXSIN	WaII	YD_L[JKLP4XSIN	WaII	YD_JLK[4JLGE4_MF[R
JYIFKM44[OKNGPJSRH	aLPXLJ\4444_LJZFLJRaLNTZ4VDTZIUJNFXQLH	L[MF4X]U\HNNZZQWOGO4444U\IJWaP\LX4YUVUXKT_aKFVQTS44DKMOI_PO]XF_
\R]4_]LFFS	QOFKWHHY	I4WXDIOSNLSY_aLH_LRM_SE4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

ZWZa_]JWQPD	]I_DOG
E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	yrq|rmeaaM]XaKQTGQ
Na	c_UMYGNJ\
4C[RM[E4\GXT\HI_L]RNIQ[
HR_
IQ[
HR_
4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C444XKP]JWQPDVWPNRD
aXZG4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\

BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
L[JKLP44WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ


BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
L[JKLP4QZ	HIYJR	HX[Xyrq|rmeaaM]XaD]SGTYaFPQHDac4444WXQZ	HIYJR	HX[XWPJ~Y[JaQNJWQPSF]
TFJD
L[JKLP4~KNZ_J[aQNJWQPSF]
TFJD
QZ	HIYJR	HX[XRYN[aTSQUDQ

4~yrq|rmeaaM]Xa\aLGRF
acVQS[aKLR_LL_GIQ[
HR_ D	]I_DOG X_RM[RYN[aTSQUDQ

	 X_RM[4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPDIOSNLSY_aLH_LRM_S44E4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ


E4L[JKLPJLK[4444C444WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
Y[JaJL_PMW[PJNZKPMO\X[I[UE4L[JKLPX_RM[4C44FJXZTXTW[RXJYHGLQV	JRX4444V_TF
KQL_HSRSHDMHD
OJRSLDGYH_UMYGNJ\	X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cV_TF
KQL_HSRSWMM[JV_TF
KQL_HSRSeSF]
TFJD
cWPJV_TF
KQL_HSRSe_UMYGNJ\
c WPJV_TF
KQL_HSRSe_UMYGNJ\
cFJXZTXTW[WPJV_TF
KQL_HSRSeXYTW[WWPHJQ_
c4OSLWORTZPaP	OWPJY[JaQNJWQPSF]
TFJD
4WXOSLWORTZPaP	O yrq|rmeaaM]XaD]SGTYaFPQHDacOSLWORTZPaP	OFJXZTXTW[E4L[JKLPX_RM[444C444HaFKDPIOJWPJY[JaQNJWQPIQ[
HR_
	4WXHaFKDPIOJ E4WOFRaMFG
RGTWPJY[JaQNJWQPD	]I_DOG
	4T]KKZPGa	a_LL_G

		

4SKQWTOS[[	T]KKZPGa	aeyrq|rmeaaM]XaWFGGDF

Ma
	cyrq|rmeaaM]XaZSHITKKZFa
	cWOFRaMFG
RGTc4SKQWTOS[[	yrq|rmeaaM]XaFL_RINU
a
cWPJSKQWTOS[[	4WXyrq|rmeaaM]XaD]SGTYaFPQHDacHaFKDPIOJSKQWTOS[[	E4L[JKLPX_RM[4C4C44L[JKLPJLK[4C44XKP]JWQPWO_RFZOKWPKXa\4E444WOFRaMFG
RGTWPJY[JaQNJWQPSF]
TFJD
	4KNZ_J[aQNJWQPRYN[aTSQUDQ

	WOFRaMFG
RGT4KNZ_J[aQNJWQPXYTW[WWPHJQ_
	yrq|rmeaaM]XaD]SGTYaFPQHDac4C444XKP]JWQPG
HW
VN	]OQ[4E444KSZ
H	MT
H_LL_G4JLGE4KSZ
H	MT
HeIQ[
HR_
	
cRINYW\WDWV_QNR
I	4KSZ
H	MT
HeD	]I_DOG
	cnvnah{lmwqp4KSZ
H	MT
He_UMYGNJ\
	cyrq|rmeaaM]XaFOMVMVNG[KNac4KSZ
H	MT
HeIQ[
HR_
		cyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
	WMaMMR4KSZ
H	MT
HeRYN[aTSQUDQ

	cyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
WMaSKRJWMWJ[4KSZ
H	MT
HeIQ[
HR_
cWMM[Jyrq|rme_UMYGNJ\
cMJLWPYyrq|rmeSF]
TFJD
c4KSZ
H	MT
HeIQ[
HR_

cWMM[Jam{lh{le_UMYGNJ\cyrq|rmeaaM]Xa[NP\	U	acMJLWPYam{lh{leRYN[aTSQUDQ
c
4HJNX\_MG\WMM[Jyrq|rmeXYTW[WWPHJQ_

cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeSF]
TFJD

cyrq|rmeaaM]XaVMQGFWM]acyrq|rmeRYN[aTSQUDQ


c4KSZ
H	MT
HeIQ[
HR_
cHJNX\_MG\444KSZ
H	MT
HeIQ[
HR_
cyrq|rmeaaM]XaNJ]SSODDIGGaacHJNX\_MG\4KSZ
H	MT
HeXYTW[WWPHJQ_
	c[SNJGyrq|rmeRYN[aTSQUDQ

c4444KSZ
H	MT
HeXYTW[WWPHJQ_
c[SNJGyrq|rmeSF]
TFJD
c4KSZ
H	MT
HeSF]
TFJD
cyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
WPJ~Y[JaQNJWQPRYN[aTSQUDQ

4KSZ
H	MT
HeXYTW[WWPHJQ_

caZTNULYVSS
]RYN[aTSQUDQ


4KSZ
H	MT
HeSF]
TFJD
cyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
WPJ~Y[JaQNJWQPD	]I_DOG
44KSZ
H	MT
HeSF]
TFJD
	cyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
WPJ~Y[JaQNJWQPIQ[
HR_
4KSZ
H	MT
HeIQ[
HR_
cyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_WPJ~Y[JaQNJWQPSF]
TFJD4G
SM	KLTZOJP[HKOPMXO	]LQ4KSZ
H	MT
HeSF]
TFJDc~yrq|rmeaaM]XaJSJX
DZZNIIJacG
SM	KLTZOJP[H_UMYGNJ\HNDKTHQVTMIJHP~yrq|rmeaaM]XaHSO\NMa_Da
cG
SM	KLTZOJP[HRYN[aTSQUDQ
X_RM[PKRR	4KSZ
H	MT
HeD	]I_DOG
c~yrq|rmeaaM]XaJSJX
DZZNIIJacG
SM	KLTZOJP[H_UMYGNJ\HNDKTHQVTMIJHP~yrq|rmeaaM]XaHSO\NMa_Da
cG
SM	KLTZOJP[HIQ[
HR_X_RM[PKRR	
4KSZ
H	MT
HeD	]I_DOG	c~yrq|rmeaaM]XaJSJX
DZZNIIJacG
SM	KLTZOJP[HSF]
TFJDHNDKTHQVTMIJHP~yrq|rmeaaM]XaHSO\NMa_Da
cG
SM	KLTZOJP[HXYTW[WWPHJQ_X_RM[PKRR

4]ILXXM
OMFXGXYTW[WWPHJQ_YFJN
WLK\P|mnjvY4N_OTIX_VGXYTW[WWPHJQ_YFJN
WLK\P|mnjvY4KSZ
H	MT
HeRYN[aTSQUDQ
c4XQL[_]V_LL_GMGUOK\T\L]G
SM	KLTZOJP[H|mnjvRYN[aTSQUDQ
_MJ]KWGHRUE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]KWGHRU]ILXXM
OMFXGRYN[aTSQUDQ

KSZ
H	MT
HeIQ[
HR_c4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]KWGHRUN_OTIX_VGWPJ~yrq|rmeaaM]Xa_GRUDISIa	cJ]KWGHRUN_OTIX_VG yrq|rmeaaM]XaD]SGTYaFPQHDac
E4KSZ
H	MT
HeSF]
TFJDc4\L[_U4C4C4444KPM[JN_OTIX_VGJ]KWGHRU444QSLNKNXWF]yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~yrq|rmeaaM]Xa[PD\GWFacD	]I_DOGX_RM[44WXyrq|rmeaaM]XaIMI

\G\\a
cQSLNKNXWF]BBQSLNKNXWF]BBQSLNKNXWF]XYTW[WWPHJQ_	QSLNKNXWF]RYN[aTSQUDQ
4KSZ
H	MT
HeXYTW[WWPHJQ_c~yrq|rmeaaM]XaJSJX
DZZNIIJac|mnjvQSLNKNXWF]yrq|rmeaaM]Xa_K_QN_\W	a]a	cMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c|mnjvQSLNKNXWF]D	]I_DOGX_RM[444KSZ
H	MT
HeXYTW[WWPHJQ_c~yrq|rmeaaM]XaJSJX
DZZNIIJac|mnjvIQ[
HR_yrq|rmeaaM]Xa_K_QN_\W	a]a	cMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c|mnjvIQ[
HR__UMYGNJ\X_RM[4KSZ
H	MT
HeXYTW[WWPHJQ_
c~yrq|rmeaaM]XaJSJX
DZZNIIJac|mnjvXYTW[WWPHJQ_yrq|rmeaaM]Xa_K_QN_\W	a]a	cMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c|mnjvD	]I_DOGX_RM[PKRR	IQ[
HR_X_RM[4KSZ
H	MT
HeRYN[aTSQUDQ
	cZ[XWP[ZD	]I_DOG4KSZ
H	MT
HeIQ[
HR_cZ[XWP[Z_UMYGNJ\BBZ[XWP[ZRYN[aTSQUDQ
BBZ[XWP[ZXYTW[WWPHJQ_BByrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_BByrq|rmeaaM]Xa[	aQ\_KWK[Xa
cXYTW[WWPHJQ_BBWMM[Jyrq|rme_UMYGNJ\cBByrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	4KSZ
H	MT
He_UMYGNJ\cWPJY[JaQNJWQPRYN[aTSQUDQ

4KSZ
H	MT
HeRYN[aTSQUDQ
cWPJY[JaQNJWQPD	]I_DOG
	4KSZ
H	MT
He_UMYGNJ\
cWPJY[JaQNJWQPSF]
TFJD
	4444Ga[XY]SZX	RGUOJ[XOIWQSF]
TFJD
_LL_G4XI_VaJ[DO4ZOWW_JFLQFTQQ[4WXyrq|rmeaaM]Xa]HYHVUa
cGa[XY]SZX	RE4XQL[_]VGa[XY]SZX	R_MGLaSFK[\]aDaE4WX\_JFJP[XW[	IGLaSFK[\]aDa]QPJWPK[4XI_VaJ[DO4444QHP\	IVLNMLyrq|rmeaaM]Xa]HYHVUa
cGLaSFK[\]aDaWPJWMM[JGLaSFK[\]aDaeD	]I_DOG
cGLaSFK[\]aDaeXYTW[WWPHJQ_
c4MFFWQVHQVyrq|rmeaaM]Xa]HYHVUa
cGLaSFK[\]aDaWMM[JGLaSFK[\]aDaeRYN[aTSQUDQ

cWPJGLaSFK[\]aDaeIQ[
HR_
c4WXQHP\	IVLNMLMFFWQVHQVBBMFFWQVHQVyrq|rmeaaM]XaD]SGTYaFPQHDacZOWW_JFLQFTQQ[4C4C4KSZ
H	MT
HeIQ[
HR_

cXI_VaJ[DO4KSZ
H	MT
HeXYTW[WWPHJQ_
cZOWW_JFLQFTQQ[4QWZW\YN\J]W\Syrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~Y[JaQNJWQPXYTW[WWPHJQ_
4KSZ
H	MT
HeD	]I_DOG
	cyrq|rmeaaM]XaIMI

\G\\a
cQWZW\YN\J]W\Syrq|rmeaaM]Xa[NP\	U	acQWZW\YN\J]W\SF
F44HNUHGV	
YDDXO\yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
~Y[JaQNJWQPIQ[
HR_
_LL_G_LL_G44KSZ
H	MT
HeIQ[
HR_cyrq|rmeaaM]Xa]HYHVUa
cHNUHGV	
YDDXO\[SNJGHNUHGV	
YDDXO\eJcBB[SNJGHNUHGV	
YDDXO\eRYN[aTSQUDQ
c4C]_J]VjVLQI_\R[Q	MNQOPFDE4KSZ
H	MT
HeSF]
TFJDcyrq|rmeaaM]Xa[NP\	U	acQ	MNQOPFD Y[Js[MM_Y[4C]_J]V{F][NJWQPQ	MNQOPFDE4KSZ
H	MT
HeIQ[
HR_cyrq|rmeaaM]Xa[NP\	U	acQ	MNQOPFD Y[Js[MM_Y[	4C4L[JKLPKSZ
H	MT
H4C444444XKP]JWQPHDTVSDHaU	KDNIVXX4E44WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E4L[JKLPMJLWPYMWJ[aKLRIQ[
HR_4444C4L[JKLPyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
MJLWPYINaRQYWPaKLR4C44XKP]JWQPWWKaQPMV	TTXKZW_GKXT][OOXLV\\PRI4444E4HMYSQa4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E444HMYSQaMJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLR]QPMJ_PJSF]
TFJD4C4WXHMYSQayrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4HMYSQaMJLWPYyrq|rmeaaM]XaaJVVW]M\acY[JaMWJ[aKLR]QPMJ_PJRYN[aTSQUDQ
4C44WXHMYSQayrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4HMYSQaMJLWPYyrq|rmeaaM]XaaJVVW]M\acY[Ja\RQYWPXQRYN[aTSQUDQ
]QPMJ_PJRYN[aTSQUDQ
4C4WXHMYSQayrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E4HMYSQaMJLWPYyrq|rmeaaM]XaaJVVW]M\acMJLWPYY[JaQNJWQPD	]I_DOG]QPMJ_PJSF]
TFJD4444C4WXHMYSQaWMM[Jam{lh{le_UMYGNJ\cE4HMYSQaMJLWPYam{lh{leD	]I_DOGc444C4WXHMYSQaWMM[Jam{lh{leXYTW[WWPHJQ_
cE4HMYSQaMJLWPYam{lh{leSF]
TFJD
c4C444WXHMYSQaE4L[JKLPXT][OOXLV\\PRI4C4L[JKLPHMYSQa4C4XKP]JWQPPHD	Q]LNLVVM]TFGSF\a4E4JLGE444YNIVZ\_PLZLVDyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_WPJ~yrq|rmeaaM]Xa[PD\GWFacXYTW[WWPHJQ_4444WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
~yrq|rmeaaM]XaX	UM	IQQaVa
cF_\F4IR[XLPVZMJQYNIVZ\_PLZLVD F]FYNIVZ\_PLZLVD
	YNIVZ\_PLZLVD	YNIVZ\_PLZLVD YNIVZ\_PLZLVD	
`4WXVM]TFGSF\a IR[XLPVZMJQ VM]TFGSF\aIR[XLPVZMJQVM]TFGSF\a4yrq|rmeRYN[aTSQUDQ
cyrq|rmeaaM]XaZRTJRVaacJLK[IR[XLPVZMJQ4444WXDIOSNLSY_aLH_LRM_SE4L[JKLP4444C4WXZPO_XHQ_]L_ZD	]I_DOGE4L[JKLP44C44YW_NMY[OTGyrq|rmeaaM]XaZRTJRVaacJLK[4XUFN_T
	QLDHVTJFV
O	MUVWPJIR[XLPVZMJQ4WX444yrq|rmeaaM]Xa]HYHVUa
cXUFN_T
	QLDH4BBWMM[JXUFN_T
	QLDHeRYN[aTSQUDQ
	cBByrq|rmeaaM]XaIMI

\G\\a
cXUFN_T
	QLDHeD	]I_DOGcBBXUFN_T
	QLDHeD	]I_DOGc44BBWMM[JXUFN_T
	QLDHeD	]I_DOG
cBByrq|rmeaaM]Xa]HYHVUa
cXUFN_T
	QLDHeSF]
TFJD
cBB[SNJGXUFN_T
	QLDHeSF]
TFJD
c444E4WO_RFZOKWPKXa\4L[JKLP4C4\UQDNMaYMKZZ\XUFN_T
	QLDHeRYN[aTSQUDQ
c44QLMHQZXX	SWXUFN_T
	QLDHeXYTW[WWPHJQ_	c4444SY	]ZUMDJLRRXYTW[WWPHJQ_	\UQDNMaYMKZZ\SF]
TFJD
4SY	]ZUMDJLRRIQ[
HR_	yrq|rmeaaM]Xa_K_QN_\W	a]a	c\UQDNMaYMKZZ\_UMYGNJ\	_UMYGNJ\
4LI_]JUL[[W	_Hyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGMJLWPYY[JaQNJWQP_UMYGNJ\	
4WXLI_]JUL[[W	_Hyrq|rmeaaM]Xa_LHMQPFPD
Ma
cLI_]JUL[[W	_HQLMHQZXX	SWJLK[E4444QLMHQZXX	SWyrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaaVYPVSS
acQLMHQZXX	SW_LL_GLI_]JUL[[W	_H4yrq|rmeaaM]XaZGO[QZ	Za	cQLMHQZXX	SW4yrq|rmeaaM]XaLQG\RONGGRXWacQLMHQZXX	SWLI_]JUL[[W	_H4C[RM[WXyrq|rmeaaM]XaOG\FSVKacQLMHQZXX	SW E4yrq|rmeaaM]XaZGO[QZ	Za	cQLMHQZXX	SW4C444WXyrq|rmeaaM]XaZRTJRVaacJLK[YW_NMY[OTG WPJIR[XLPVZMJQE4WO_RFZOKWPKXa\4L[JKLP4C444PRDUJKU
MO[TaXD\TPaHWRV4WXJ]XS	YI]GXNWTZFPRDUJKU
MO[E4PRDUJKU
MO[TaXD\TPaHWRV4C44UGWK_ZDWYNO_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4XQL[_]V_LL_GY[JaQNJWQPSF]
TFJD
_LL_G_MF_aLRUKPPPL[E4WXyrq|rmeaaM]XaIMI

\G\\a
cF_aLRUKPPPL[F_aLRUKPPPL[E4444UGWK_ZDWYNOecF_aLRUKPPPL[4C4C4C44VF[QR	ZDZV_LL_G4WXZ[XWP[ZSF]
TFJDE4[P\IQ	]FXZMyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
~yrq|rmeaaM]Xa\TOUSOOMFG\a	cyrq|rmeaaM]XaNGLV\SLPGacinskanrkywpazwlSF]
TFJD	X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
c[P\IQ	]FXZME4XQL[_]V[P\IQ	]FXZM_MJ]YVRPQ[aE4VF[QR	ZDZVecyrq|rmeaaM]Xa[KDO
YMUaR\VacJ]YVRPQ[a444C4C444C44444UMGZ	XaQFKMDW]XV_LL_G4D	]I_DOG		 WWKaQPMV	TTXKZW_GK4IQ[
HR_	 RINYW\WDWV_QNR
I	44D	]I_DOG	 yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJD
44_UMYGNJ\ yrq|rmeaaM]XaNGLV\SLPGac|mnjvD	]I_DOG4IQ[
HR_ UGWK_ZDWYNO4RYN[aTSQUDQ
 VF[QR	ZDZV4IQ[
HR_
 HDTVSDHaU	KDNIVXX4XYTW[WWPHJQ_ Q\T[]JY]	XFTKYURLGPRDUJKU
MO[4IQ[
HR_ Q\T[]JXWHHJI]I
RGPRDUJKU
MO[4_UMYGNJ\	 FMWJUK[S_YR\RQTIHWHKDHNYLH[RD444HP
VYF_Nyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
INaTMQPa[P]QZ[UMGZ	XaQFKMDW]XVyrq|rmeaaM]XaZNPRLPO\YVYacUMGZ	XaQFKMDW]XV444[OHLTVMJXXZYXWLRYDITOJHP
VYF_N\UQDNMaYMKZZ\4_O	LRSPXG\]VZM_LL_G_UMYGNJ\ _UMYGNJ\4K	G[KIa[HID_TPKRR4FN_
[MLL[X_RM[444WO_RFZOKWPKXa\4yrq|rmeRYN[aTSQUDQ
cX_RM[4444XQL[_]VQLMHQZXX	SW_MJFNPOZO]QQE44QQLXZ]SHKMJIR[XLPVZMJQyrq|rmeaaM]XaZRTJRVaacJLK[YW_NMY[OTG4WXQQLXZ]SHKMJE4\L[_U4C4ZVOP
XVM	_yrq|rmeaaM]XaZSHITKKZFa
	c`
WPJQQLXZ]SHKMJ44JFNPOZO]QQyrq|rmeaaM]XaVMQGFWM]acMJLWPYJFNPOZO]QQ444WXJFNPOZO]QQE4]QPJWPK[4C44JLGE4444\aQGGRMY\UQDNMaYMKZZ\4444TLRJLFQGaU[T]PFYHWSD\XMT\RZLWZKJFNPOZO]QQ[OHLTVMJX_O	LRSPXG\]VZMZVOP
XVM	_XKP]JWQPRMU[FaK]JNV_HKKM[\aQGGRMYE4WXTXYNX
	DGPWJNyrq|rmeaaM]XaNJ]SSODDIGGaacRMU[FaK]JNV_HKE4yrq|rmeRYN[aTSQUDQ
cJLK[4L[JKLPX_RM[4C4KSZ
H	MT
HXZYXWLRYDITOJRMU[FaK]JNV_HK\aQGGRMY4WXKSZ
H	MT
HL[JKLPX_RM[4L[JKLPyrq|rmeaaM]Xa]HYHVUa
c~yrq|rmeaaM]Xa]FQGV	\Sacyrq|rmeaaM]XaVMQGFWM]acKSZ
H	MT
HJLK[4C4WXTLRJLFQGaU[TE4WX[SNJGyrq|rme_UMYGNJ\cE4QWVIDDHOPHQ[VKZM_UMYGNJ\
_UMYGNJ\
4444\L[_U444C4QWVIDDHOPHQ[VKZMIQ[
HR__UMYGNJ\JFNPOZO]QQ4]QPJWPK[4C44IKKK[UXZYXWLRYDITOJTLRJLFQGaU[T\UQDNMaYMKZZ\4WXIKKK[UE44QWVIDDHOPHQ[VKZMSF]
TFJDIQ[
HR_	JFNPOZO]QQ4]QPJWPK[4C4K	G[KIa[HID_Tyrq|rmeaaM]XaNJ]SSODDIGGaacIKKK[U 

	TXYNX
	DGPWJNyrq|rmeaaM]XaNJ]SSODDIGGaacIKKK[UPKRR~yrq|rmeaaM]Xa]FQGV	\Sacyrq|rmeaaM]XaVMQGFWM]acIKKK[UJLK[4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TE4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
E4KNZ_J[aQNJWQPIQ[
HR_	
JFNPOZO]QQ4C4FN_
[MLL[JLK[4\L[_U444C[RM[E4QWVIDDHOPHQ[VKZM_UMYGNJ\IQ[
HR_JFNPOZO]QQ4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4]QPJWPK[44C]_J]V{F][NJWQPQ	MNQOPFDE4]QPJWPK[4444C4C4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_T[SNJGyrq|rme_UMYGNJ\cE4RQJSI	XGXZYXWLRYDITOJyrq|rmeaaM]XaZNPRLPO\YVYac_LL_G4XYTW[WWPHJQ_ WWKaQPMV	TTXKZW_GK4SF]
TFJD RINYW\WDWV_QNR
I	4_UMYGNJ\	 yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP_UMYGNJ\
4444D	]I_DOG 4\UQDNMaYMKZZ\444HPTMOHYaaVNTyrq|rmeaaM]XaNGLV\SLPGacMJLJLyrq|rmeaaM]Xa\	V]W	QFacRQJSI	XGXYTW[WWPHJQ_RYN[aTSQUDQ

4XTa[
VPYTWUyrq|rmeaaM]XaWTW	TG[MacHPTMOHYaaVNT	4XQL[_]VQLMHQZXX	SW_MJFNPOZO]QQE444WXyrq|rmeaaM]XaZRTJRVaacJLK[YW_NMY[OTG IR[XLPVZMJQE4\L[_U4C4444JFNPOZO]QQyrq|rmeaaM]XaVMQGFWM]acMJLWPYJFNPOZO]QQ4WXJFNPOZO]QQE4]QPJWPK[44C4SWTK
GNWUGUYYYFJN
WLK\PWWKaQPMV	TTXKZW_GKyrq|rmeaaM]XaZRTJRVaacJLK[	`	4PLX
MHTUPyrq|rmeaaM]XaOG\FSVKacXTa[
VPYTWU444DWNH\JV	I\[yrq|rmeaaM]Xa_K_QN_\W	a]a	cJFNPOZO]QQX_RM[444XQLLTZU
DL\HLTZU
DL\HPLX
MHTUPLTZU
DL\HE444WXyrq|rmeaaM]XaZRTJRVaacJLK[YW_NMY[OTG IR[XLPVZMJQE4\L[_U4C4YM\LOL	\LTZU
DL\HPLX
MHTUP4O]SN_\[YMJFNPOZO]QQDWNH\JV	I\[SF]
TFJDSWTK
GNWUGUYYXYTW[WWPHJQ_	LTZU
DL\H_UMYGNJ\PLX
MHTUPXYTW[WWPHJQ_XTa[
VPYTWUeLTZU
DL\Hc4]D\I_KD\
M	ZGFX[HMRFF[RYYO]SN_\[YM	YM\LOL	\XKP]JWQPRMU[FaK]JNV_HKKM[\UQDNMaYMKZZ\E4KSZ
H	MT
HXZYXWLRYDITOJRMU[FaK]JNV_HK\UQDNMaYMKZZ\4WXKSZ
H	MT
HL[JKLPX_RM[4L[JKLPyrq|rmeaaM]Xa]HYHVUa
c~yrq|rmeaaM]Xa]FQGV	\Sacyrq|rmeaaM]XaVMQGFWM]acKSZ
H	MT
HJLK[4444CPKRR4444WXYM\LOL	\yrq|rmeaaM]XaIMI

\G\\a
c]D\I_KD\
M	Z]D\I_KD\
M	ZE4444aYZXZYXWLRYDITOJ]D\I_KD\
M	Z\UQDNMaYMKZZ\4]ILXXM
OMFXGaYZyrq|rmeaaM]XaNJ]SSODDIGGaacaYZ

BBTXYNX
	DGPWJNyrq|rmeaaM]XaNJ]SSODDIGGaacaYZ~yrq|rmeaaM]Xa]FQGV	\Sacyrq|rmeaaM]XaVMQGFWM]acaYZJLK[PKRR4WXyrq|rmeaaM]Xa]HYHVUa
c]ILXXM
OMFXGE4K	G[KIa[HID_T]ILXXM
OMFXG4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4KNZ_J[aQNJWQPRYN[aTSQUDQ
JFNPOZO]QQ4C4\L[_U4C4444C444C4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TE4\L[_U4C4C4444C4yrq|rmeSF]
TFJDcX_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TE4L[JKLP4C4WXFN_
[MLL[E4MR	PFGJMNZ	4C4WXFMWJUK[S_YRyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4Z[R[J[aQNJWQPLF[]P
	ON
Z
IQ[
HR_	44KPM[Jyrq|rmeRYN[aTSQUDQ
ceLF[]P
	ON
Z
D	]I_DOG	c4C4WXWMM[Jyrq|rmeD	]I_DOG	cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeRYN[aTSQUDQ

cyrq|rmeSF]
TFJD
c_LL_G4yrq|rmeSF]
TFJD
cyrq|rmeaaM]XaY	OD_MOOKGPa
	cyrq|rmeaaM]XaaVYPVSS
acyrq|rmeIQ[
HR_cFMWJUK[S_YR4WXWMM[JK	G[KIa[HID_Te_UMYGNJ\cyrq|rmeaaM]XaIMI

\G\\a
cK	G[KIa[HID_TeSF]
TFJDcE4KPM[Jyrq|rme_UMYGNJ\	c44YZLONMQQNRK	G[KIa[HID_TeRYN[aTSQUDQ
cWMM[JK	G[KIa[HID_TeXYTW[WWPHJQ_cyrq|rmeaaM]XaIMI

\G\\a
cK	G[KIa[HID_Te_UMYGNJ\cK	G[KIa[HID_Te_UMYGNJ\c[SNJGK	G[KIa[HID_TeRYN[aTSQUDQ
c4C44V
GMLVMaX_RM[4FL\]WGUJM[K_LL_G44WXWMM[JK	G[KIa[HID_TeSF]
TFJD
cyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TeRYN[aTSQUDQ

cE4444MLIIGOGHOPU_LL_G44444XQL[_]VK	G[KIa[HID_TeRYN[aTSQUDQ

c_MWGIQa[KKMIE4WXyrq|rmeaaM]XaIMI

\G\\a
cWGIQa[KKMIWGIQa[KKMIE4MLIIGOGHOPUecWGIQa[KKMI4C4C4ITMSYVYHyrq|rmeXYTW[WWPHJQ_
	c444MLIIGOGHOPUVLTKTV
SL_KGKFGWWMLIIGOGHOPU4yrq|rmeIQ[
HR_cMLIIGOGHOPU4FL\]WGUJM[KeIQ[
HR_
cMLIIGOGHOPU4WX[SNJGyrq|rmeaaM]XaaVYPVSS
acMLIIGOGHOPUITMSYVYHBB[SNJGyrq|rmeaaM]XaaVYPVSS
acITMSYVYHMLIIGOGHOPUE444V
GMLVMaJLK[4C4C44WXWMM[JK	G[KIa[HID_TeD	]I_DOG

cyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TeRYN[aTSQUDQ


cE4MLIIGOGHOPU_LL_G44XQL[_]VK	G[KIa[HID_TeD	]I_DOGc_MWGIQa[KKMIE4WXyrq|rmeaaM]XaIMI

\G\\a
cWGIQa[KKMIWGIQa[KKMIE4444MLIIGOGHOPUecWGIQa[KKMI4C4C4ITMSYVYHyrq|rmeSF]
TFJD
c4MLIIGOGHOPUVLTKTV
SL_KGKFGWWMLIIGOGHOPU4yrq|rmeSF]
TFJD
cMLIIGOGHOPU4FL\]WGUJM[KeIQ[
HR_cMLIIGOGHOPU4WX[SNJGyrq|rmeaaM]XaaVYPVSS
acMLIIGOGHOPUITMSYVYHBB[SNJGyrq|rmeaaM]XaaVYPVSS
acITMSYVYHMLIIGOGHOPUE4444V
GMLVMaJLK[444C4C4444WXWMM[JK	G[KIa[HID_TeIQ[
HR_cyrq|rmeaaM]XaIMI

\G\\a
cK	G[KIa[HID_TeSF]
TFJDcE4R[SFF
RHYVaZTNULYVSS
]_UMYGNJ\4WXR[SFF
RHYVWPJGUOJ[XOIWQXYTW[WWPHJQ_
E4SY	]ZUMDJLRRIQ[
HR_SF]
TFJD4WXWPJGUOJ[XOIWQIQ[
HR_	SY	]ZUMDJLRRD	]I_DOGRYN[aTSQUDQ
4444C444yrq|rmeD	]I_DOG

cK	G[KIa[HID_TeIQ[
HR_c444FL\]WGUJM[Ke_UMYGNJ\cK	G[KIa[HID_TeXYTW[WWPHJQ_c4WXyrq|rmeaaM]XaaQKLGJP]_OIacK	G[KIa[HID_TeRYN[aTSQUDQ
cyrq|rmeaaM]XaaQKLGJP]_OIacR[SFF
RHYVBBWPJGUOJ[XOIWQD	]I_DOGE4WXSY	]ZUMDJLRR_UMYGNJ\K	G[KIa[HID_TeXYTW[WWPHJQ_cXYTW[WWPHJQ_BBaZTNULYVSS
]IQ[
HR_K	G[KIa[HID_TeSF]
TFJDcE4SY	]ZUMDJLRRXYTW[WWPHJQ_RYN[aTSQUDQ
4JLGE4WXJ]_O\[OMVYGFX
WGXSY	]ZUMDJLRRRYN[aTSQUDQ
D	]I_DOG4C]_J]VjVLQI_\R[Q	MNQOPFDE44C]_J]V{F][NJWQPQ	MNQOPFDE4C4C[RM[E4WO_RFZOKWPKXa\4L[JKLP4C4C4KPM[JR[SFF
RHYV44C4VWJNR]TSWMM[JK	G[KIa[HID_TeIQ[
HR_

	cyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TeSF]
TFJD

	cK	G[KIa[HID_TeRYN[aTSQUDQ
c_LL_G4WXWMM[JVWJNR]TSeRYN[aTSQUDQ

cyrq|rmeaaM]XaIMI

\G\\a
cVWJNR]TSe_UMYGNJ\cE4WXyrq|rmeaaM]XaNJ]SSODDIGGaacVWJNR]TSeSF]
TFJDc 
E4yrq|rme_UMYGNJ\


cVWJNR]TSeD	]I_DOGc4FL\]WGUJM[Ke_UMYGNJ\cVWJNR]TSeSF]
TFJDc4C[RM[E4yrq|rmeSF]
TFJD


c4FL\]WGUJM[KeRYN[aTSQUDQ
	c4SY	]ZUMDJLRRIQ[
HR_D	]I_DOG4C4C4WXWMM[JVWJNR]TSeD	]I_DOGcyrq|rmeaaM]XaIMI

\G\\a
cVWJNR]TSeRYN[aTSQUDQ
cE4WXyrq|rmeaaM]XaNJ]SSODDIGGaacVWJNR]TSeIQ[
HR_c E4yrq|rmeXYTW[WWPHJQ_

cVWJNR]TSeIQ[
HR_
c444FL\]WGUJM[KeD	]I_DOG
cVWJNR]TSeD	]I_DOG
c4C[RM[E4yrq|rmeIQ[
HR_

c4FL\]WGUJM[Ke_UMYGNJ\
c4SY	]ZUMDJLRRRYN[aTSQUDQ

IQ[
HR_44C4C44HW
R_]YRFMIGWMM[JK	G[KIa[HID_TeXYTW[WWPHJQ_
cyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TeXYTW[WWPHJQ_
cK	G[KIa[HID_TeXYTW[WWPHJQ_
c_LL_G4GR	TIFRY_LL_G4XYTW[WWPHJQ_

 SF]
TFJD

4IQ[
HR_
 XYTW[WWPHJQ_
4444RYN[aTSQUDQ

	 RYN[aTSQUDQ

4SF]
TFJD
 IQ[
HR_444XYTW[WWPHJQ_ _UMYGNJ\4D	]I_DOG IQ[
HR_
44XQL[_]VGR	TIFRY_MW[OTPLOQ]\_HYJY ZPDYT	WSaE4WXWMM[JHW
R_]YRFMIGeW[OTPLOQ]\_HYJYcyrq|rmeaaM]XaIMI

\G\\a
cHW
R_]YRFMIGeW[OTPLOQ]\_HYJYcyrq|rmeaaM]XaNJ]SSODDIGGaacHW
R_]YRFMIGeW[OTPLOQ]\_HYJYc E4FL\]WGUJM[KeZPDYT	WSacHW
R_]YRFMIGeW[OTPLOQ]\_HYJYc4C44C4WXWMM[JK	G[KIa[HID_TeXYTW[WWPHJQ_
cyrq|rmeaaM]Xa_\XLLLPacK	G[KIa[HID_TeSF]
TFJD
cE4IQLaW\IVSYWPJK	G[KIa[HID_TeIQ[
HR_
c4WXIQLaW\IVSY IQLaW\IVSY	FL\]WGUJM[KeRYN[aTSQUDQ

cIQLaW\IVSY4C4WXWMM[JK	G[KIa[HID_TeSF]
TFJD	
cyrq|rmeaaM]Xa_\XLLLPacK	G[KIa[HID_TeSF]
TFJDcE44a]WWPJK	G[KIa[HID_TeIQ[
HR_	c4WXa]W 	a]W


FL\]WGUJM[KeIQ[
HR_	ca]W4C4WX[SNJGFL\]WGUJM[KE4Z[R[J[aQNJWQPD	]I_DOG
	4Z[R[J[aQNJWQP_UMYGNJ\4KNZ_J[aQNJWQP_UMYGNJ\
yrq|rmeaaM]XaD]SGTYaFPQHDac44Z[R[J[aJL_PMW[PJSF]
TFJD4U\IJWaP\LX4DKMOI_PO]XF_
\R]4L[JKLP4C444SNK	JMF]D
WHDMHD
OJRSLDGYHSF]
TFJDX_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cSNK	JMF]D
WE4FL\]WGUJM[Kyrq|rmeaaM]XaZOVZW
]WRZLLKa	cSNK	JMF]D
WFL\]WGUJM[K444C44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE444FJXZTXTW[RXJYHGLQV	JRX4WXWMM[JFL\]WGUJM[KeD	]I_DOGcWPJFL\]WGUJM[KeSF]
TFJDc 
WPJFL\]WGUJM[KeD	]I_DOGcFFXX[FJXZTXTW[WPJFL\]WGUJM[KeD	]I_DOGc4M[JaJL_PMW[PJNZKPMO\X[I[UFL\]WGUJM[KFJXZTXTW[4C44444444WXN_IR_L_NTa[RXYTW[WWPHJQ_FL\]WGUJM[K_UMYGNJ\E4V\WPTVXT_XLXHDMHD
OJRSLDGYHRYN[aTSQUDQ
PKRR4WXyrq|rmeaaM]Xa]HYHVUa
cV\WPTVXT_XLXBBV\WPTVXT_XLXFL\]WGUJM[KE4444WO_RFZOKWPKXa\4L[JKLP4C4KPM[JV\WPTVXT_XLX4C4WXWMM[JFL\]WGUJM[KeD	]I_DOGcyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4_]	]VV
FHQINaY[JaM]V[ZKR[Za[H[PJSWHLLXDFJUGMKT4WX_]	]VV
FHQWPJ_]	]VV
FHQ WPJ[LH_RWPJFL\]WGUJM[KeRYN[aTSQUDQ
cE4INa]R[_LaM]V[ZKR[ZaVQQUSWHLLXDFJUGMKT4INaM]V[ZKR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDacyrq|rmeaaM]XaFL_RINU
a
cRYN[aTSQUDQ
SWHLLXDFJUGMKT44C4C4KNZ_J[aQNJWQP_UMYGNJ\	yrq|rmeaaM]XaD]SGTYaFPQHDac4Z[R[J[aQNJWQPD	]I_DOG
	4Z[R[J[aQNJWQPIQ[
HR_4Z[R[J[aJL_PMW[PJ_UMYGNJ\4U\IJWaP\LX4DKMOI_PO]XF_
\R]444WXV
GMLVMaE4ZWQGUX]Z\WY_WL4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4CXWP_RRGE4KPM[Jyrq|rmeSF]
TFJD	c4FT_Q_YTVaGTSF]
TFJD4C44C44XKP]JWQPYZLONMQQNRYaJJPMYIX
V[G_aMQKSUFUKGNLZD
X_RM[4E4WXZPO_XHQ_]L_ZXYTW[WWPHJQ_L[JKLP44JLGE4]ZOTTFT\QTKK[JO	JU_WaWWOJZK[	S4444WX]ZOTTFT\QTKK yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	TXYNX
	DGPWJNyrq|rmeaaM]XaNJ]SSODDIGGaacYaJJPMYIE4444QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	XYTW[WWPHJQ_	4L[JKLP4C44KPM[J]ZOTTFT\QTKK44P_
ZUP\WM~yrq|rmeaaM]Xa]HN[Q	\\KPOVacYaJJPMYIJLK[4WXyrq|rmeaaM]XaIMI

\G\\a
cP_
ZUP\WMyrq|rmeaaM]XaNJ]SSODDIGGaacP_
ZUP\WM 		

P_
ZUP\WMT_DLVDPGFPFPaDQRKP_
ZUP\WM4WXP_
ZUP\WMBByrq|rmeaaM]XaNJ]SSODDIGGaacP_
ZUP\WMFZF	BByrq|rmeaaM]Xa_K_QN_\W	a]a	cP_
ZUP\WMSF]
TFJD	E4L[JKLP4444C4WXGQS[a	
DD\SGLHVP_
ZUP\WME4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	RYN[aTSQUDQ
	
444L[JKLP444C4WXyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
yrq|rmeaaM]Xa[NP\	U	acP_
ZUP\WM
	S[NG	LIO_E4WXX
V[G_aMQX
V[G_aMQS[NG	LIO_ecE4444QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	IQ[
HR_	4L[JKLP4C4X
V[G_aMQS[NG	LIO_ec4C[RM[E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	IQ[
HR_		44L[JKLP4C4WXKSUFUKGNLZD
H[LMWQPa]QSN_L[X
V[G_aMQRINYW\WDWV_QNR
I	E4L[JKLP444C4D\PSYDHPJYY\WJKRYWPPS4WXD\PSYDHBByrq|rmeaaM]XaNJ]SSODDIGGaacD\PSYDH
	E4444QWVIDDHOPHQ[VKZMSF]
TFJD	IQ[
HR_	4L[JKLP4C4OFWPaOMOY[JaQNJWQPXYTW[WWPHJQ_44WXyrq|rmeaaM]XaIMI

\G\\a
cOFWPaOMOyrq|rmeaaM]Xa_K_QN_\W	a]a	cOFWPaOMOyrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WMBE4L[JKLP4444C4_DN[[LORyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPRYN[aTSQUDQ

yrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WM4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac_DN[[LORE444L[JKLP4C4KPM[J_DN[[LOR4WXKSUFUKGNLZD
E4V_SZMXG\IK~Y[JaQNJWQPIQ[
HR_	4WXyrq|rmeaaM]XaIMI

\G\\a
cV_SZMXG\IKyrq|rmeaaM]Xa_K_QN_\W	a]a	cV_SZMXG\IKyrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WMBE444WUFZFLSXWPJyrq|rmeaaM]Xa[NP\	U	acV_SZMXG\IKyrq|rmeaaM]Xa_K_QN_\W	a]a	cV_SZMXG\IKB4WXWUFZFLSXyrq|rmeaaM]XaD]SGTYaFPQHDacWUFZFLSX
L[JKLP4C4KPM[JV_SZMXG\IKWUFZFLSX4C4NXFYFTRSG_X_RM[444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ


yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4FRWSVZYRLJYaVyrq|rmeaaM]Xa\aLGRF
acVQS[aKLR_LL_GRYN[aTSQUDQ
 	RYN[aTSQUDQ
 IQ[
HR_ X_RM[IQ[
HR_ 

4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	WMaINa[LLQLFRWSVZYRLJYaVE4NXFYFTRSG_WPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[FRWSVZYRLJYaV 
4C4C4GSWX	NY\DPGY[Y]X_RM[444WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E4TJXD]UWa\YDK_Y[JaQNJWQPD	]I_DOG_LL_G4GSWX	NY\DPGY[Y]yrq|rmeaaM]Xa]HYHVUa
cTJXD]UWa\YDK_yrq|rmeaaM]Xa_LHMQPFPD
Ma
cQFSXaFSW[	_TJXD]UWa\YDK_JLK[4C44Y_HVRRKFFH]X
]VL
RXTDWYLRT_NPTYMLP
	444WXTO[]UPZVQVUTYTXTDWYLRT_NPTYMLPG\VSaUWFRZGP_
ZUP\WME4QWVIDDHOPHQ[VKZM_UMYGNJ\	D	]I_DOG4L[JKLP4C4Xa\
Qa\
N_TUXTDWYLRT_NPTYMLP4Q_XFKXa_[MVSZ	XTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~M[JaJL_PMW[PJD	]I_DOG
	
4SU	IUNTQSDXX_RM[4WXNXFYFTRSG_yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\

yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4SJPQN	QR4XQLPO_F_a\OUPO_F_a\OUPO_F_a\OUE4P]OWKL[WR[yrq|rmeaaM]Xa\aLGRF
acVQS[aKLRD	]I_DOGyrq|rmeaaM]XaFL_RINU
a
cF	ZXF]
	
	_LL_GSF]
TFJD `D	]I_DOG IQ[
HR_ X_RM[RYN[aTSQUDQ
	 
444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGWMaINa[LLQLP]OWKL[WR[E4WXPO_F_a\OUyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\yrq|rmeaaM]XaZUTOXXQaQac44]QPJWPK[4C4V_TF
KQL_HSRSWPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[P]OWKL[WR[44WXV_TF
KQL_HSRSBByrq|rmeaaM]Xa_LHMQPFPD
Ma
cV_TF
KQL_HSRS_LL_G	




	
	

	JLK[E4444WXPO_F_a\OUyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDyrq|rmeaaM]XaZUTOXXQaQac4]QPJWPK[44C4SJPQN	QRV_TF
KQL_HSRS4\L[_U4C4WXSJPQN	QRQWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	RYN[aTSQUDQ
4WXSJPQN	QRSJPQN	QRSU	IUNTQSDXJLK[444WXSJPQN	QRSJPQN	QR E444JaZK\FXOKTTO[]UPZVQVUTYTXTDWYLRT_NPTYMLPG\VSaUWFRZGD\PSYDH4WXJaZK\FXOKTJaZK\FXOKTTO[]UPZVQVUTYTXTDWYLRT_NPTYMLPD\PSYDH4\S[aQ
[_yrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WM4444URHRFGZ
FM~Y[JaQNJWQPSF]
TFJD4JNFP_G]LZ	WNX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cURHRFGZ
FMyrq|rmeaaM]Xa_K_QN_\W	a]a	cURHRFGZ
FM\S[aQ
[_BE4_K	_I

aWPJyrq|rmeaaM]Xa[NP\	U	acURHRFGZ
FMyrq|rmeaaM]Xa_K_QN_\W	a]a	cURHRFGZ
FMB4JNFP_G]LZ	WN_K	_I

ayrq|rmeaaM]XaD]SGTYaFPQHDac_K	_I

a yrq|rmeaaM]XaD]SGTYaFPQHDac_K	_I

a	4C4WXJNFP_G]LZ	WNE4KNZ_J[aQNJWQPD	]I_DOG\S[aQ
[_Byrq|rmeaaM]XaD]SGTYaFPQHDacIQ[
HR_4~Z[R[J[aQNJWQPIQ[
HR_4C[RM[E444~KNZ_J[aQNJWQPSF]
TFJD\S[aQ
[_Byrq|rmeaaM]XaD]SGTYaFPQHDacBSJPQN	QRXYTW[WWPHJQ_4444C4KPM[J\S[aQ
[_URHRFGZ
FMJNFP_G]LZ	WN_K	_I

a4WXJaZK\FXOKTE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
IQ[
HR_
SJPQN	QR4L[JKLP4C4Q_XFKXa_[MVSZ	XTDWYLRT_NPTYMLP4Xa\
Qa\
N_TUXTDWYLRT_NPTYMLP4PJYY\WJKRYWPPSJLK[444]_TSGKYNR	aUMMJLK[4XNRGULSXHyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
4XQL[_]V_LL_Gyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP\PQQYLWZWNM]_KP_MTXROOUFOLFVLHE444~yrq|rmeaaM]XaYR\Y]GUO[a	cTXROOUFOLFVLHSF]
TFJDXNRGULSXH444~yrq|rmeaaM]XaYR\Y]GUO[a	cTXROOUFOLFVLHXYTW[WWPHJQ_XNRGULSXH4C4WXGSWX	NY\DPGY[Y]OWSW[YWPZ	XJMI]F\\MV]P	LLKZQFSXaFSW[	_4yrq|rmeIQ[
HR_c4DKMOI_PO]XF_
\R]44QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
_UMYGNJ\	SJPQN	QR4L[JKLP4C4444C4WL	U[XNRY[JaQNJWQPRYN[aTSQUDQ
4444WXyrq|rmeaaM]XaIMI

\G\\a
cWL	U[XNRyrq|rmeaaM]Xa_K_QN_\W	a]a	cWL	U[XNRyrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WMBZ[R[J[aQNJWQPD	]I_DOG4~yrq|rmeaaM]XaYR\Y]GUO[a	cyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPSF]
TFJD
yrq|rmeaaM]XaaQKLGJP]_OIacP_
ZUP\WM4KPM[JWL	U[XNR4WXSU	IUNTQSDX~Z[R[J[aQNJWQPIQ[
HR_	4WXX
V[G_aMQE444yrq|rmeRYN[aTSQUDQ
cX
V[G_aMQ4444\LaVOQQHKFWIPXTDWYLRT_NPTYMLPX
V[G_aMQ4C4WXKSUFUKGNLZD
E4444IG	aWYaP	Kyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
444XQL[_]V_LL_Gyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP\PQQYLWZWNM]_KP_MUWKP[SK
OTMIRE4~yrq|rmeaaM]XaYR\Y]GUO[a	cUWKP[SK
OTMIRRYN[aTSQUDQ
IG	aWYaP	K4C444KPM[JIG	aWYaP	KUWKP[SK
OTMIR4C4SY	]ZUMDJLRR_UMYGNJ\	P_
ZUP\WMXYTW[WWPHJQ_444PJYY\WJKRYWPPSJLK[4]_TSGKYNR	aUMMJLK[4yrq|rme_UMYGNJ\c4DKMOI_PO]XF_
\R]4Y_HVRRKFFH]X
]VL
RXTDWYLRT_NPTYMLP4WXQ_XFKXa_[MVSZ	XTDWYLRT_NPTYMLPI_HUSY[\MMDZQUHXTDWYLRT_NPTYMLP4KNZ_J[aQNJWQP_UMYGNJ\	X
V[G_aMQByrq|rmeaaM]XaD]SGTYaFPQHDacRYN[aTSQUDQ
4C]_J]VjVLQI_\R[Q	MNQOPFDE4444QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4CXWP_RRGE4FT_Q_YTVaGTXYTW[WWPHJQ_	4C4C4XKP]JWQPSSUPZXVSWJNGG]G]4E4WXZ[XWP[ZXYTW[WWPHJQ_	
BByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	E4WXyrq|rmeaaM]XaVWRNOHYa]Oa	c|mnjvD	]I_DOG		E4L[OKWL[aQP][|mnjvSF]
TFJD		444C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4L[JKLP4C4C4444UK_LWD
_ITaY[JaNRKYWPM4WXyrq|rmeaaM]Xa]HYHVUa
cUK_LWD
_ITaE444L[JKLP4C4RWMJ_LL_G4XQL[_]VUK_LWD
_ITa_M\_M[P_S[ UNPXHJ]LE4WX\_M[P_S[QFSXaFSW[	_E4]QPJWPK[4C44RWMJe\_M[P_S[cUNPXHJ]L4C4L[JKLPRWMJ4444C4XKP]JWQPZOTKaHKZOOFTKZPOQNIaLXWN[ZKNS\ZNGDHIW44E44KRVZ_GODDV~yrq|rmeaaM]XaHSO\NMa_Da
cPOQNIaLXWX_RM[PKRR
	4WXKRVZ_GODDVE4L[JKLPX_RM[4444C44XQL[_]VN[ZKNS\ZNGDHIW_MaU
ZaWHUFE44WXyrq|rmeaaM]XaIMI

\G\\a
caU
ZaWHUFBBaU
ZaWHUFBByrq|rmeaaM]XaNJ]SSODDIGGaacaU
ZaWHUF 
		E4]QPJWPK[4444C44444JLGE4]IFHJ	W_M~yrq|rmeaaM]Xa_[
SWPR]NacaU
ZaWHUFKRVZ_GODDV44C]_J]VjVLQI_\R[SVR]YP
JSXTVE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	SVR]YP
JSXTV444]QPJWPK[44C]_J]V{F][NJWQPSVR]YP
JSXTVE4]QPJWPK[4C44444WX]IFHJ	W_ME4L[JKLPJLK[4C4C4L[JKLPX_RM[4C44XKP]JWQPSSTIRSaXDJGPaP	ZZNNRKYWPa\_M[P_S[4E4444N[ZKNS\ZNGDHIWyrq|rmeXYTW[WWPHJQ_c444WXyrq|rmeaaM]Xa]HYHVUa
cN[ZKNS\ZNGDHIWBB[SNJGN[ZKNS\ZNGDHIWE4L[JKLPX_RM[4C4WXZ[XWP[ZIQ[
HR_	
BB[SNJGNRKYWPa\_M[P_S[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cNRKYWPa\_M[P_S[_UMYGNJ\

X_RM[E4L[JKLPX_RM[4C444NIZPaYMYD_DinanrkywpazwlNRKYWPa\_M[P_S[4WXyrq|rmeaaM]Xa]FMXaRDGSQacNRKYWPa\_M[P_S[E4PORUXFG_G
I_LL_GNIZPaYMYD_D44C[RM[E444ZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D4WXyrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWBByrq|rmeaaM]XaXMMOZPIRa
cZFNXLaR
WNWJSWE4L[JKLPX_RM[4C4PORUXFG_G
IOPVMXNTM\JUaNVZZFNXLaR
WNWJSW_LL_GD	]I_DOG	SF]
TFJD
	IQ[
HR_	SF]
TFJD	SF]
TFJD4C44444XQL[_]VPORUXFG_G
I_MPOQNIaLXWE4WXyrq|rmeaaM]XaJSJX
DZZNIIJacPOQNIaLXWE4]QPJWPK[4C4WXZOTKaHKZOOFTKZPOQNIaLXWN[ZKNS\ZNGDHIWE4444L[JKLPJLK[4C4C4L[JKLPX_RM[4C4XKP]JWQPOPVMXNTM\JUaNVZZFNXLaR
WNWJSW[F_XZMR	I]IUK[FSPRJKUGWMU	LHMPKRRYKKI_TNL_JPKRR4E4RWMJ_LL_G4WXUK[FSPRJ E4L[JKLPRWMJ4C4WXKUGWMU	LHMPKRRE4KUGWMU	LHM_LL_G4YKKI_TNL_Jyrq|rmeaaM]XaZRTJRVaacJLK[`4444C4WXyrq|rmeaaM]XaZRTJRVaacJLK[ YKKI_TNL_JE44L[JKLPRWMJ4C4WXyrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWE4L[JKLPRWMJ4C4RaYLaVQFGaZ~yrq|rmeaaM]XaI	WS[XMPacZFNXLaR
WNWJSW444WXRaYLaVQFGaZX_RM[E4WXWMM[JKUGWMU	LHMeRaYLaVQFGaZcE4L[JKLPRWMJ4C4KUGWMU	LHMeRaYLaVQFGaZcJLK[4C4XRLFIH]NQLP]KURFMDRXZFNXLaR
WNWJSW	
		4444WXyrq|rmeaaM]Xa]HYHVUa
cXRLFIH]NE4L[JKLPRWMJ4C444XQL[_]VXRLFIH]N_MDJ
YT\	NFJ[H
E44WXyrq|rmeaaM]XaZRTJRVaacJLK[ YKKI_TNL_JBByrq|rmeaaM]XaOG\FSVKacRWMJ F]F
E4\L[_U4C4NIZPaYMYD_DZFNXLaR
WNWJSWDJ
YT\	NFJ[H
4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cNIZPaYMYD_DE4]QPJWPK[4C4WX~yrq|rmeaaM]XaS

	ZLD	a
cNIZPaYMYD_DE4RWMJyrq|rmeaaM]XaZOVZW
]WRZLLKa	cRWMJOPVMXNTM\JUaNVZNIZPaYMYD_D[F_XZMR	I]IUK[FSPRJKUGWMU	LHMYKKI_TNL_J4C[RM[WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE4OL\RYXDZLXOLTSyrq|rmeaaM]XaQVIZMF
UWMPacNIZPaYMYD_D]QPMJ_PJD	]I_DOG	444OL\RYXDZLXOLTSyrq|rmeaaM]XaIMI

\G\\a
cOL\RYXDZLXOLTSyrq|rmeaaM]XaRJLRacOL\RYXDZLXOLTS4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cOL\RYXDZLXOLTS[F_XZMR	I]IJLK[E4RWMJecNIZPaYMYD_D4C4C4C4L[JKLPRWMJ4C44XKP]JWQPYSTO
_OD
HTZFHNRKYWPa\_M[P_S[444E444WXyrq|rmeaaM]XaIMI

\G\\a
cNRKYWPa\_M[P_S[BBNRKYWPa\_M[P_S[E4L[JKLPX_RM[4C4444WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cNRKYWPa\_M[P_S[RYN[aTSQUDQ


X_RM[E4L[JKLPX_RM[4C44444NRKYWPa\_M[P_S[yrq|rmeaaM]XaVMQGFWM]acNRKYWPa\_M[P_S[4WXNRKYWPa\_M[P_S[QFSXaFSW[	_E4L[JKLPX_RM[4C44WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	
yrq|rmeaaM]XaVWRNOHYa]Oa	c|mnjvSF]
TFJD		E444L[OKWL[aQP][|mnjvSF]
TFJD		4C44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	WMaNRKYWPa_]JWH[NRKYWPa\_M[P_S[E4Z[_]JWH_J[aNRKYWPM_LL_GNRKYWPa\_M[P_S[JLK[4C4444ZFNXLaR
WNWJSWZ[XWP[Z_UMYGNJ\	
inanrkywpazwlyrq|rmeaaM]Xa]FMXaRDGSQacNRKYWPa\_M[P_S[4WXZFNXLaR
WNWJSWyrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacNRKYWPa\_M[P_S[yrq|rmeaaM]Xa]FMXaRDGSQacNRKYWPa\_M[P_S[E4WXYM	VTJKO[SNGZFNXLaR
WNWJSWE4L[JKLPJLK[4C4C44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	E44WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
		BB]KLL[PJaKM[La]_PSF]
TFJD	E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	E4KM[LMY[JaKM[LM_LL_G_UMYGNJ\	 RYN[aTSQUDQ
	_UMYGNJ\	 4WX[SNJGKM[LMKM[LMec wzE4yrq|rmeaaM]XaJLJKYO[UZQLDa	cKM[LMec wz4C[RM[E4yrq|rmeaaM]XaJLJKYO[UZQLDa	c4C4C4C44444RRaTQ_Z[R[J[aNRKYWPM_LL_GNRKYWPa\_M[P_S[4WXWMaINa[LLQLRRaTQ_E44L[JKLP\QQRRRaTQ_4C4C4L[JKLPX_RM[44C44XKP]JWQPYM	VTJKO[SNGZFNXLaR
WNWJSWUK[FSPRJ444E4WXUK[FSPRJ F]F
E4L[JKLPX_RM[4C4WXyrq|rmeaaM]XaIMI

\G\\a
cZFNXLaR
WNWJSWBBZFNXLaR
WNWJSWBByrq|rmeaaM]Xa_K_QN_\W	a]a	cZFNXLaR
WNWJSWSF]
TFJD

X_RM[E4L[JKLPX_RM[4444C4YP\NWGZa]aULN~yrq|rmeaaM]XaI	WS[XMPacZFNXLaR
WNWJSW4WXYP\NWGZa]aULNX_RM[BByrq|rmeaaM]XaS

	ZLD	a
cYP\NWGZa]aULNE4L[JKLPX_RM[4C4N[N[[JWOWGXKZaZ[XWP[ZSF]
TFJD	
~yrq|rmeaaM]XaI	WS[XMPacinanrkywpazwlX_RM[444WXN[N[[JWOWGXKZaX_RM[BBYP\NWGZa]aULNN[N[[JWOWGXKZayrq|rmeaaM]Xa_K_QN_\W	a]a	cYP\NWGZa]aULNN[N[[JWOWGXKZazwl{}jqlgam{nljqlE4L[JKLPX_RM[4444C44IT\HGZUXF_FGK~yrq|rmeaaM]XaPWQFKO
D
LacYP\NWGZa]aULN4WXyrq|rmeaaM]Xa]HYHVUa
cIT\HGZUXF_FGKE4L[JKLPX_RM[444C4XQL[_]VIT\HGZUXF_FGK_MF]XH	HOaFYE44WXF]XH	HOaFYBBF]XH	HOaFYIQ[
HR_

E4]QPJWPK[4444C44NIZPaYMYD_DYP\NWGZa]aULN]QPMJ_PJD	]I_DOG	F]XH	HOaFY4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cNIZPaYMYD_DE4_I	Q]G
P
NIZPaYMYD_D4]QPJWPK[4C4444WX~yrq|rmeaaM]XaS

	ZLD	a
cNIZPaYMYD_DE4YM	VTJKO[SNGNIZPaYMYD_DUK[FSPRJ44C[RM[E4WX_I	Q]G
P
NIZPaYMYD_DE4Y_HVRRKFFH]X
]VL
RNIZPaYMYD_DF	_F_4_I	Q]G
P
NIZPaYMYD_D4C4C4C4WX~yrq|rmeaaM]XaGaWRR]U__[acYP\NWGZa]aULNE4Y_HVRRKFFH]X
]VL
RYP\NWGZa]aULN
4~yrq|rmeaaM]XaGaWRR]U__[acYP\NWGZa]aULN4C4L[JKLP~yrq|rmeaaM]XaVWRNOHYa]Oa	cYP\NWGZa]aULN4C444444XKP]JWQPZWQGUX]Z\WY_WL4E44JLGE44RWMJSSUPZXVSWJNGG]G]4WXyrq|rmeaaM]Xa]HYHVUa
cRWMJE4L[JKLP4C44UONF
\QXa	_LL_G4444VJ[HUDSTX_RM[4XQL[_]Vyrq|rmeaaM]XaW_	L\NQ_
Va	cRWMJ_M\_M[P_S[E44WXyrq|rmeaaM]XaIMI

\G\\a
c\_M[P_S[E4]QPJWPK[4C44YFMWRYII\Kyrq|rmeaaM]Xa]FMXaRDGSQac\_M[P_S[4444WXYFMWRYII\KE4YFMWRYII\K\_M[P_S[4C4WXWMM[JUONF
\QXa	eYFMWRYII\KcE444]QPJWPK[4C44UONF
\QXa	eYFMWRYII\KcJLK[4WXSSTIRSaXDJGPaP	ZZN\_M[P_S[E4YSTO
_OD
HTZFH\_M[P_S[4VJ[HUDSTJLK[4C4C44WX~yrq|rmeaaM]XaS

	ZLD	a
c\PQQYLWZWNM]_KPE4]TZJYTNZMQLP]KURFMDRX\PQQYLWZWNM]_KP
	4WXyrq|rmeaaM]Xa]HYHVUa
c]TZJYTNZME4444N[ZKNS\ZNGDHIWyrq|rmeXYTW[WWPHJQ_		c4XQL[_]V]TZJYTNZM_MDJ
YT\	NFJ[H
E4444WXDJ
YT\	NFJ[H
VKYYDIHNYQPMTE4]QPJWPK[4C444POQNIaLXW\PQQYLWZWNM]_KPDJ
YT\	NFJ[H
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacPOQNIaLXWBByrq|rmeaaM]XaRJLRacyrq|rmeaaM]XaQVIZMF
UWMPacDJ
YT\	NFJ[H
]QPMJ_PJD	]I_DOG	RYN[aTSQUDQ

	E4]QPJWPK[4C4444444WXZOTKaHKZOOFTKZPOQNIaLXWN[ZKNS\ZNGDHIWE4_I	Q]G
P
POQNIaLXW4VJ[HUDSTJLK[4C4C4C4C44KFQGHTFyrq|rmeD	]I_DOG
c4WXyrq|rmeaaM]Xa]HYHVUa
cKFQGHTF[SNJGKFQGHTFE4WXI[	P[GJF_NZI[MI]FWKFQGHTFE4VJ[HUDSTJLK[4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD	Q	MNQOPFD44C]_J]V{F][NJWQPQ	MNQOPFDE4C4C44XKP]JWQPG\PQPIQ	NDGN\[4E4JLGE4XIDTaNUKOW	[WPJY[JaQNJWQPXYTW[WWPHJQ_	4WXyrq|rmeaaM]XaD]SGTYaFPQHDacXIDTaNUKOW	[ FF[E4KNZ_J[aQNJWQPXYTW[WWPHJQ_	yrq|rmeaaM]XaD]SGTYaFPQHDac4UQD
PKQNQPVTU_LL_G_LL_G]	\O_VSMFRGQL_DI_LL_GD	]I_DOG4MQRG[J[FXNFGIR
yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	yrq|rmeaaM]XaFHHDS]ZRTNa	c4WXMQRG[J[FXNFGIR
MQRG[J[FXNFGIR
]	\O_VSMFRGQL_DIUQD
PKQNQPVTUec_LL_GMQRG[J[FXNFGIR
_LL_GXYTW[WWPHJQ_	SF]
TFJD	4XQL[_]VUQD
PKQNQPVTU_M_JK[	N]VHYQYE4XQL[_]V_JK[	N]VHYQYec_M_YF
JVNE4[XULR\]LGONyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~yrq|rmeaaM]Xa\TOUSOOMFG\a	c_JK[	N]VHYQYec_YF
JVNX_RM[4WXyrq|rmeaaM]Xa]HYHVUa
c[XULR\]LGON]QPJWPK[4XQL[_]V[XULR\]LGON_MSR\\	P[WJ[K_QE444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacSR\\	P[WJ[K_Q]QPJWPK[44WXyrq|rmeaaM]Xa[NP\	U	acSR\\	P[WJ[K_Q
SF]
TFJD	
]QPJWPK[4ZRROW_ZDD~yrq|rmeaaM]Xa_GRUDISIa	cSR\\	P[WJ[K_Q4WXZRROW_ZDDX_RM[yrq|rmeaaM]XaD]SGTYaFPQHDacZRROW_ZDD 


_I	Q]G
P
SR\\	P[WJ[K_Q4C4444C4C444TJXD]UWa\YDK_Y[JaQNJWQPD	]I_DOG_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cTJXD]UWa\YDK_TJXD]UWa\YDK__LL_G4444H\\LTWUyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJD	4aNZZ[XWP[Z_UMYGNJ\
ina}qpj{pjazwl|mnjvXYTW[WWPHJQ_	RYN[aTSQUDQ
		4XQL[_]Vyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	caNZRYN[aTSQUDQ
	_LL_G_MOSVHHMa
_[XE4WXyrq|rmeaaM]Xa[KDO
YMUaR\Vacyrq|rmeaaM]Xa]FMXaRDGSQacOSVHHMa
_[XH\\LTWU]QPJWPK[4RFVJQJ\_RUDKO]yrq|rmeaaM]Xa[KDO
YMUaR\Vacyrq|rmeaaM]Xa]FMXaRDGSQacOSVHHMa
_[Xyrq|rmeaaM]Xa[KDO
YMUaR\VacOSVHHMa
_[X4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cRFVJQJ\_RUDKO]TJXD]UWa\YDK_JLK[]QPJWPK[4WX~yrq|rmeaaM]XaURRZW
ITGa
cOSVHHMa
_[X]QPJWPK[4VSIWPIY\~yrq|rmeaaM]XaNDD_U_S]R\\acOSVHHMa
_[X444WXVSIWPIY\BBVSIWPIY\ 
	
	
]QPJWPK[4V_TF
KQL_HSRS~yrq|rmeaaM]XaHSO\NMa_Da
cOSVHHMa
_[X4WXyrq|rmeaaM]XaIMI

\G\\a
cV_TF
KQL_HSRSBByrq|rmeaaM]Xa_K_QN_\W	a]a	cV_TF
KQL_HSRSD	]I_DOG	
X_RM[]QPJWPK[4GQN\OJGPKVROyrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_	
V_TF
KQL_HSRS4444WXyrq|rmeaaM]XaIMI

\G\\a
cGQN\OJGPKVROBBGQN\OJGPKVROV_TF
KQL_HSRSBBGQS[a	
DD\SGLHVGQN\OJGPKVRO]QPJWPK[4TO[]UPZVQVUTYTOSVHHMa
_[XGQN\OJGPKVRO4444WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~QN]_]V[aWPH_RWZ_J[OSVHHMa
_[XJLK[4C4KPM[JTJXD]UWa\YDK_H\\LTWUaNZOSVHHMa
_[XRFVJQJ\_RUDKO]VSIWPIY\V_TF
KQL_HSRSGQN\OJGPKVRO4KSKH
FYRM]\XLGaW]K4C44YPLD
Y[M	RIyrq|rme_UMYGNJ\	
c4444KFQGHTFyrq|rmeRYN[aTSQUDQ

c44444JIXaDDY
FYyrq|rmeaaM]Xa]HYHVUa
cYPLD
Y[M	RI[SNJGYPLD
Y[M	RIBByrq|rmeaaM]Xa]HYHVUa
cKFQGHTF[SNJGKFQGHTF4WXJIXaDDY
FYE4L[JKLP4C444TTZPQ	RDIWPJY[JaQNJWQPD	]I_DOG	
4WXyrq|rmeaaM]XaD]SGTYaFPQHDacTTZPQ	RDI
	E4L[JKLP4C4WXZPO_XHQ_]L_ZSF]
TFJD	

E4L[JKLP4C44JLGE4TTZPQ	RDIWPJY[JaQNJWQPD	]I_DOG	
4WXyrq|rmeaaM]XaD]SGTYaFPQHDacTTZPQ	RDI
E44L[JKLP4C4KNZ_J[aQNJWQPSF]
TFJD	
yrq|rmeaaM]XaD]SGTYaFPQHDac4ZWQGUX]Z\WY_WL4CXWP_RRGE4FT_Q_YTVaGTIQ[
HR_	
4C444C]_J]VjVLQI_\R[Q	MNQOPFDE44QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	
	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE444C4C44XKP]JWQPLLX]Y	URYFKU	TFIMRG4444E4JLGE44XaQDFYTWPJYY\WJKRYWPPS444WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW
	L[JKLP4WXGQS[a	
DD\SGLHVXaQDFYTWE444QWVIDDHOPHQ[VKZMSF]
TFJD	
IQ[
HR_	
4L[JKLP4C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
Y[JaJL_PMW[PJ_UMYGNJ\L[JKLP44HXG_NW]N	\PQQYLWZWNM]_KP4]R[_LMJ_J]_]V[JLK[4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cHXG_NW]N	~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	E4L[JKLP44C4444WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	E4444M\UN_MUZNVU~KS_MU4MO]\DJR_OJ
	ZVVPHXG_NW]N		
JLK[4~KS_MUM\UN_MUZNVU4444Y_HVRRKFFH]X
]VL
RHXG_NW]N	
4]R[_LMJ_J]_]V[JLK[44C[RM[WX~yrq|rmeaaM]XaXMMOZPIRa
cHXG_NW]N	BB~yrq|rmeaaM]XaURRZW
ITGa
cHXG_NW]N	E4Y_HVRRKFFH]X
]VL
RHXG_NW]N	
	4]R[_LMJ_J]_]V[JLK[4444C44WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	~yrq|rmeaaM]XaXMMOZPIRa
cHXG_NW]N	BB~yrq|rmeaaM]XaURRZW
ITGa
cHXG_NW]N	~yrq|rmeaaM]XaGaWRR]U__[acHXG_NW]N	E4M\UN_MUZNVU~KS_MU44MO]\DJR_OJ
	ZVVPHXG_NW]N	
JLK[4~KS_MUM\UN_MUZNVU4Y_HVRRKFFH]X
]VL
RHXG_NW]N	
	4]R[_LMJ_J]_]V[JLK[4C44]R[_LMJ_J]_]V[JLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	BB~yrq|rmeaaM]XaURRZW
ITGa
cHXG_NW]N	BB~yrq|rmeaaM]XaXMMOZPIRa
cHXG_NW]N	E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	
RYN[aTSQUDQ
	44UYXXKHNLI
X_RM[4XQL[_]V_LL_Gyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~yrq|rmeaaM]Xa\TOUSOOMFG\a	cHXG_NW]N	SF]
TFJD	_LL_G_MSXKXYTDZXODE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacSXKXYTDZXODaKIGURZU\I_P
SaFSXKXYTDZXOD
		MQ\WLYZaV
PWT	KHUZSXKXYTDZXODEIHPXVXNL_VN\MGYaMSXKXYTDZXODUYXXKHNLI
JLK[C4C44WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	[TSM]VFID	aQPDPKRRE4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~Z[R[J[aJL_PMW[PJIQ[
HR_	4]R[_LMJ_J]_]V[JLK[4444C4WX~yrq|rmeaaM]XaS

	ZLD	a
cHXG_NW]N	BB~yrq|rmeaaM]XaURRZW
ITGa
cHXG_NW]N	BB~yrq|rmeaaM]XaXMMOZPIRa
cHXG_NW]N	E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~M[JaJL_PMW[PJRYN[aTSQUDQ
	UYXXKHNLI
	4KPM[JUYXXKHNLI
SXKXYTDZXOD4L[JKLP4C4KPM[JUYXXKHNLI
SXKXYTDZXOD4444C444NHP[N	HXQJHXG_NW]N	VKYYDIHNYQPMT4WX\J

DH]GQG	FQINHP[N	HXQJE444L[JKLP44C4]\K[WQ
GHDQ\~yrq|rmeaaM]XaJSJX
DZZNIIJacNHP[N	HXQJYLLGXD	WRM]	[DNHP[N	HXQJX_RM[4WX~yrq|rmeaaM]XaNDD_U_S]R\\acNHP[N	HXQJ FXFyrq|rmeaaM]XaIMI

\G\\a
c]\K[WQ
GHDQ\yrq|rmeaaM]XaaQKLGJP]_OIac]\K[WQ
GHDQ\yrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWE4Xa\
Qa\
N_TUNHP[N	HXQJ4YFRORF
PPKTS4VH	]TWI
]WDZG4L[JKLP4C4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNHP[N	HXQJ~yrq|rmeaaM]XaNDD_U_S]R\\acNHP[N	HXQJ FZ	F\E4VYLNJIZVJMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cNHP[N	HXQJX_RM[PKRR

4WXyrq|rmeaaM]XaIMI

\G\\a
cVYLNJIZVJyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
VYLNJIZVJaZSH[LMWQPa]QSN_L[aZSecRINYW\WDWV_QNR
I	 L[JKLP4KPM[JVYLNJIZVJaZS4C4WX]\K[WQ
GHDQ\PKRRL[JKLP44KPM[J]\K[WQ
GHDQ\44I\KZLXXRXKTO[]UPZVQVUTYTNHP[N	HXQJG\VSaUWFRZGXaQDFYTW4444WXI\KZLXXRXKBB~yrq|rmeaaM]XaVWRNOHYa]Oa	cNHP[N	HXQJBB~yrq|rmeaaM]XaNDD_U_S]R\\acNHP[N	HXQJFFE4WXI\KZLXXRXK~yrq|rmeaaM]XaJSJX
DZZNIIJacNHP[N	HXQJE4VYLNJIZVJMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cNHP[N	HXQJX_RM[PKRR

4[JLMZ
	GKVyrq|rmeaaM]XaIMI

\G\\a
cVYLNJIZVJyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_	
VYLNJIZVJaZSH[LMWQPa]QSN_L[aZSecRINYW\WDWV_QNR
I	 4KPM[JVYLNJIZVJaZS4WX[JLMZ
	GKVE4Y_HVRRKFFH]X
]VL
RNHP[N	HXQJ	4_I	Q]G
P
NHP[N	HXQJ4C4C4444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~M[JaJL_PMW[PJD	]I_DOG	FZ\F	4L[JKLP4C4444I_HUSY[\MMDZQUHNHP[N	HXQJ4Y_HVRRKFFH]X
]VL
RNHP[N	HXQJ444Xa\
Qa\
N_TUNHP[N	HXQJ444YFRORF
PPKTS4VH	]TWI
]WDZG4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\	
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4444C4C4XKP]JWQP_LJZFLJRaLNTZ4E4444JLGE4NDISX_YLSGVVyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
WPJY[JaQNJWQPSF]
TFJD	44WXNDISX_YLSGVVyrq|rmeaaM]XaD]SGTYaFPQHDac	BBNDISX_YLSGVV yrq|rmeaaM]XaD]SGTYaFPQHDacE4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
~KNZ_J[aQNJWQPRYN[aTSQUDQ
	yrq|rmeaaM]XaD]SGTYaFPQHDac4M\UN_MUZNVUGUOJ[XOIWQRYN[aTSQUDQ
	4QOKN[NJIVJNTVQ
MOI_UDNY[WULRyrq|rmeaaM]XaIMI

\G\\a
cM\UN_MUZNVUM\UN_MUZNVU4M[RJZ
PRGV	JVOR]WXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cM\UN_MUZNVUBByrq|rmeaaM]XaNJ]SSODDIGGaacM\UN_MUZNVU
	BBRKHMW]\JKFVM\UN_MUZNVUBBQOKN[NJIVJBBM[RJZ
PPKRRM[RJZ
PH[LMWQPa]QSN_L[M[RJZ
PQOKN[NJIVJ E4XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWRKHMW]\JKFVXaQDFYTWE44NH
[XOF\LIDJW\\VNTVQ
MOI_UDNY[WULRXaQDFYTW4444WXyrq|rmeaaM]XaIMI

\G\\a
cM\UN_MUZNVUBByrq|rmeaaM]XaNJ]SSODDIGGaacM\UN_MUZNVUBBRKHMW]\JKFVM\UN_MUZNVUBBQOKN[NJIVJBBNH
[XOF\LIDJW\\VH[LMWQPa]QSN_L[NH
[XOF\LIDJW\\VQOKN[NJIVJ E4SY	]ZUMDJLRRD	]I_DOG	XaQDFYTWRYN[aTSQUDQ
4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
E444~KNZ_J[aQNJWQPSF]
TFJD	IQ[
HR_4~KNZ_J[aQNJWQPXYTW[WWPHJQ_	_UMYGNJ\		4~KNZ_J[aQNJWQPIQ[
HR_
	D	]I_DOG		44C4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~Z[R[J[aJL_PMW[PJNZKPMO\X[I[U4C4C4C4C44WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4LTSRQRFUPVY[JaQNJWQPIQ[
HR_	4WXLTSRQRFUPVX_RM[LTSRQRFUPVRINYW\WDWV_QNR
I	E4~KNZ_J[aQNJWQPSF]
TFJD	RINYW\WDWV_QNR
I	SF]
TFJD		4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	BB_ZZaQNJWQPIQ[
HR_	RINYW\WDWV_QNR
I	RYN[aTSQUDQ
		E4L[JKLP4C44X]U\HNNZZQWOGO4444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
E4~KNZ_J[aQNJWQP_UMYGNJ\	_UMYGNJ\		4~KNZ_J[aQNJWQPD	]I_DOG	XYTW[WWPHJQ_		4~KNZ_J[aQNJWQPXYTW[WWPHJQ_
	XYTW[WWPHJQ_		44C4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	
~Z[R[J[aJL_PMW[PJNZKPMO\X[I[U44WX[SNJGXaQDFYTWRKHMW]\JKFVXaQDFYTWE4SY	]ZUMDJLRRXYTW[WWPHJQ_	XaQDFYTWXYTW[WWPHJQ_	4C4J]XS	YI]GXNWTZFPKRR444Y_HVRRKFFH]X
]VL
RXTDWYLRT_NPTYMLP
4444\GXT\HI_L]RNXYTW[WWPHJQ_
D	]I_DOG
44\GXT\HI_L]RN_UMYGNJ\
_UMYGNJ\		4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	Q	MNQOPFD4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~Z[R[J[aQNJWQP_UMYGNJ\	4C]_J]V{F][NJWQPQ	MNQOPFDE4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~Z[R[J[aQNJWQPIQ[
HR_	4C4C444XKP]JWQP[R[G]
JLYa4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_

E4~yrq|rmeaaM]Xa\aLGRF
acVQS[aKLR_LL_GIQ[
HR_		 
D	]I_DOG X_RM[RYN[aTSQUDQ

	 X_RM[4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_		Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C44XKP]JWQPRVUO	UID[[KVPFOJ4E4MJ_JW]WX]WM_LMSGTX_RM[444WXWX]WM_LMSGTL[JKLP4WX]WM_LMSGTJLK[4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_		BBWMa_ZSWPE4L[JKLP4C4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\		BB]KLL[PJaKM[La]_PSF]
TFJD		
E4L[JKLP444C4XGSP[\]DWLOWMM[Jal{ok{mjeD	]I_DOG		cal{ok{mjeXYTW[WWPHJQ_		c4XGSP[\]DWLOyrq|rmeaaM]XaIMI

\G\\a
cXGSP[\]DWLOyrq|rmeaaM]XaVMQGFWM]acXGSP[\]DWLO4444WXXGSP[\]DWLOXYTW[WWPHJQ_			XGSP[\]DWLORYN[aTSQUDQ
		E4L[JKLP4C44JQaZUMDF_LL_G4WXXGSP[\]DWLOXYTW[WWPHJQ_			E4OIL_RPDVLJDWMM[Jal{ok{mjeIQ[
HR_cal{ok{mjeRYN[aTSQUDQ
c4OIL_RPDVLJDyrq|rmeaaM]XaIMI

\G\\a
cOIL_RPDVLJDyrq|rmeaaM]XaVMQGFWM]acOIL_RPDVLJD4WXOIL_RPDVLJDOIL_RPDVLJDQFSXaFSW[	_E4JQaZUMDFecOIL_RPDVLJD4C444C[RM[E44444SLa
RYOTaIWMM[Jal{ok{mje_UMYGNJ\		cal{ok{mjeXYTW[WWPHJQ_		c_LL_G4SLa
RYOTaIyrq|rmeaaM]Xa]HYHVUa
cSLa
RYOTaISLa
RYOTaI_LL_G4XQL[_]VSLa
RYOTaI_MOIL_RPDVLJDE4OIL_RPDVLJDyrq|rmeaaM]XaIMI

\G\\a
cOIL_RPDVLJDyrq|rmeaaM]XaVMQGFWM]acOIL_RPDVLJD4WXOIL_RPDVLJDOIL_RPDVLJDQFSXaFSW[	_E4JQaZUMDFecOIL_RPDVLJD444C4C4C4WX[SNJGJQaZUMDFE4L[JKLP4C4VJ[HUDSTX_RM[4XQL[_]VJQaZUMDF_MOIL_RPDVLJDE4WXSSTIRSaXDJGPaP	ZZNOIL_RPDVLJDE4YSTO
_OD
HTZFHOIL_RPDVLJD4VJ[HUDSTJLK[4C4C4WXVJ[HUDSTE44WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	E4INaM_X[aL[ZWL[]J_ZSWPaKLR_UMYGNJ\	4C4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE44QWVIDDHOPHQ[VKZMIQ[
HR_	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C44XKP]JWQPUF]R]QHS]NQ]ZGQ\ZSYYWaT]WPPI[GSP4E4WXT]WPPI[GSPD	]I_DOG	
E4NRKYWPMyrq|rmeIQ[
HR_	c4WXWMM[JNRKYWPMeRYN[aTSQUDQ
	
cBByrq|rmeaaM]Xa]HYHVUa
cNRKYWPMeXYTW[WWPHJQ_	
cE4L[JKLPNQ]ZGQ\ZSYYWa4C4[\ZTX	R\	[RZ[XWP[ZD	]I_DOG	ina}qpj{pjazwlZ[XWP[ZSF]
TFJD|mnjvSF]
TFJD		4WX[\ZTX	R\	[RE4L[JKLPNQ]ZGQ\ZSYYWa4C4WRWSLJ]GMD_LL_GD	]I_DOG	 _UMYGNJ\	D	]I_DOG	 IQ[
HR_	4444XQL[_]VWRWSLJ]GMD_MVVT]DILM _YF
JVNE4WXWMM[JNRKYWPMeD	]I_DOG	ceVVT]DILMcE444]QPJWPK[4C4444OQ\J[aHG~yrq|rmeaaM]XaHSO\NMa_Da
c[\ZTX	R\	[RVVT]DILM444WXyrq|rmeaaM]XaIMI

\G\\a
cOQ\J[aHGBByrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHG_UMYGNJ\	_YF
JVN_UMYGNJ\	
X_RM[E444]QPJWPK[4444C444NIUYY[]YX_yrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_	_YF
JVNXYTW[WWPHJQ_	_YF
JVNIQ[
HR_		OQ\J[aHG4WXyrq|rmeaaM]XaIMI

\G\\a
cNIUYY[]YX_E4]QPJWPK[4C4NIUYY[]YX_yrq|rmeaaM]XaVMQGFWM]acNIUYY[]YX_4WXNIUYY[]YX_BBNIUYY[]YX_D	]I_DOG	BBNIUYY[]YX__UMYGNJ\
E4KPM[JNRKYWPMeXYTW[WWPHJQ_	ceVVT]DILMc4C4C4L[JKLPNQ]ZGQ\ZSYYWa4C4WXT]WPPI[GSPXYTW[WWPHJQ_	E4L[JKLPNQ]ZGQ\ZSYYWa4C44NRKYWPMyrq|rmeIQ[
HR_	c4XKWJUO]S\DVZyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4WXWMM[JNRKYWPMeD	]I_DOG	ceXKWJUO]S\DVZcE4KPM[JNRKYWPMe_UMYGNJ\	ceXKWJUO]S\DVZc4C4L[JKLPNQ]ZGQ\ZSYYWa4C4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4XKP]JWQPSFH]UaTZFOT
KDDaJFTR4E4444WXOWSW[YWPZ	XJME4L[JKLP4C44J]YVRPQ[ayrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
	4WQ		OJJYKH
PDUOaGPQ]VFQS_QJ]YVRPQ[a4[]VQXYTW[WWPHJQ_[M]a_JJLJ]YVRPQ[aXYTW[WWPHJQ_[M]a_JJLWQ		OJJYKH
PDUOXYTW[WWPHJQ_4[]VQIQ[
HR_
[M]aTMJ]YVRPQ[aSF]
TFJD[M]aTMWQ		OJJYKH
PDUORYN[aTSQUDQ
4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	E4XKP]JWQPJUOPHRN\PY\IGQRDNJI44E4WXyrq|rmeaaM]XaJFVY[	SJPKa	cGQRDNJIE4L[JKLPGQRDNJI4C4J]YVRPQ[aQFSXaFSW[	_4WXWMM[JGQRDNJI L[MNQPM[eJ]YVRPQ[acE4444KPM[JGQRDNJI L[MNQPM[eJ]YVRPQ[ac4C444L[JKLPGQRDNJI4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4XKP]JWQPOVZNFZNLMZ_UPP	JSYNRKYWPM4444E4G
SM	KLTZOJP[HQFSXaFSW[	_4WXWMM[JNRKYWPMeG
SM	KLTZOJP[HcE4KPM[JNRKYWPMeG
SM	KLTZOJP[Hc4C4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPIQ[
HR_	4WQ		OJJYKH
PDUOaGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4WXWMM[JNRKYWPMeWQ		OJJYKH
PDUOcE4KPM[JNRKYWPMeWQ		OJJYKH
PDUOc4C4444L[JKLPNRKYWPM444C444C4XKP]JWQPPSJ]Ra]P	OFW[NGLaFKUS
KaT[MV4E4WXyrq|rmeaaM]Xa]HYHVUa
cLaFKUS
KaT[MVE4L[JKLPLaFKUS
KaT[MV4C4XSUQ\[U44WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\yrq|rmeaaM]XaVWRNOHYa]Oa	cXTDWYLRT_NPTYMLPE4RX\RH]Y
VJJJY[JaNRKYWPaZ_J_XTDWYLRT_NPTYMLPX_RM[X_RM[4444XSUQ\[UWMM[JRX\RH]Y
VJJJeXYTW[WWPHJQ_cRX\RH]Y
VJJJeSF]
TFJDc4C4PORIUJYVDVT_LL_GXYTW[WWPHJQ__UMYGNJ\4XQL[_]VPORIUJYVDVT_MHODNFH\Y[YIZZE4WXWMM[JLaFKUS
KaT[MVeHODNFH\Y[YIZZceSF]
TFJDcBByrq|rmeaaM]Xa]HYHVUa
cLaFKUS
KaT[MVeHODNFH\Y[YIZZceSF]
TFJDcE4]QPJWPK[4C4444XQL[_]VLaFKUS
KaT[MVeHODNFH\Y[YIZZceD	]I_DOGc_MU[G SLOHMZM
MI\E4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cU[GQFSXaFSW[	_X_RM[BBU[GQFSXaFSW[	_E4KPM[JLaFKUS
KaT[MVeHODNFH\Y[YIZZceRYN[aTSQUDQ
ceU[Gc4]QPJWPK[44C4WXXSUQ\[UU[GXSUQ\[UE4KPM[JLaFKUS
KaT[MVeHODNFH\Y[YIZZce_UMYGNJ\ceU[Gc4]QPJWPK[4C4C444C444XQL[_]V_LL_G_UMYGNJ\
RYN[aTSQUDQ
_MVXH_IHQWIJE4TLT	UQOG
WMM[JLaFKUS
KaT[MVeVXH_IHQWIJceXYTW[WWPHJQ_cyrq|rmeaaM]Xa]HYHVUa
cLaFKUS
KaT[MVeVXH_IHQWIJce_UMYGNJ\cLaFKUS
KaT[MVeVXH_IHQWIJceRYN[aTSQUDQ
c_LL_G4WXTLT	UQOG
]QPJWPK[4444IDWUKL
DZ[XWP[ZIQ[
HR_inskanrkywpazwlZ[XWP[ZXYTW[WWPHJQ_	ina}qpj{pjazwlIQ[
HR_4J
D]P__LL_G4WXXSUQ\[UJ
D]P_ecXSUQ\[U4J
D]P_ecyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4WXIDWUKL
D~yrq|rmeaaM]XaS

	ZLD	a
cIDWUKL
Dyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cIDWUKL
DD	]I_DOG_MSXKXYTDZXODE4DU[L[YMZaMYFW~yrq|rmeaaM]XaHSO\NMa_Da
cSXKXYTDZXODX_RM[PKRR	

	4WXyrq|rmeaaM]XaIMI

\G\\a
cDU[L[YMZaMYFWBByrq|rmeaaM]Xa_K_QN_\W	a]a	cDU[L[YMZaMYFWIQ[
HR_X_RM[]QPJWPK[4WXyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
DU[L[YMZaMYFWWVUGW\M[\E4YYIRYMJPONFyrq|rmeaaM]XaVMQGFWM]acWVUGW\M[\ec44WXYYIRYMJPONFJ
D]P_ecYYIRYMJPONF4444C444J
D]P_ecyrq|rmeaaM]Xa[KDO
YMUaR\VacSXKXYTDZXOD4C4444C4XQL[_]VTLT	UQOG
_MU[G SLOHMZM
MI\E4XQL[_]VJ
D]P__MVaXRRDMPFIPKE4WXU[GVaXRRDMPFIPKBBU[GM_PWJWD[aJ[FJaXW[RZVaXRRDMPFIPKE44KPM[JLaFKUS
KaT[MVeVXH_IHQWIJce_UMYGNJ\ceU[Gc4\L[_U44C4C4C4C4LFNLKLR
]JJJWMM[JLaFKUS
KaT[MVeSF]
TFJDceRYN[aTSQUDQ
cyrq|rmeaaM]Xa]HYHVUa
cLaFKUS
KaT[MVeRYN[aTSQUDQ
ce_UMYGNJ\cLaFKUS
KaT[MVeRYN[aTSQUDQ
ceRYN[aTSQUDQ

c_LL_G4WXLFNLKLR
]JJJE4[\ZTX	R\	[RZ[XWP[ZSF]
TFJD	ina}qpj{pjazwlZ[XWP[ZXYTW[WWPHJQ_|mnjvIQ[
HR_4WRWSLJ]GMD_LL_GXYTW[WWPHJQ_	 SF]
TFJD	_UMYGNJ\ IQ[
HR_	4XQL[_]VLFNLKLR
]JJJ_MU[G SLOHMZM
MI\E4444WXWMM[JWRWSLJ]GMDeU[GcBB[\ZTX	R\	[R]QPJWPK[4OQ\J[aHG~yrq|rmeaaM]XaHSO\NMa_Da
c[\ZTX	R\	[RU[GX_RM[PKRRFZ
\F\4WXyrq|rmeaaM]XaIMI

\G\\a
cOQ\J[aHGyrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHGXYTW[WWPHJQ_	WRWSLJ]GMDeU[Gc_UMYGNJ\	
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHGRYN[aTSQUDQ
X_RM[E4KPM[JLaFKUS
KaT[MVeD	]I_DOGceRYN[aTSQUDQ

ceU[Gc4C4C4C4L[JKLPLaFKUS
KaT[MV4C44XKP]JWQPF\VFP[FOUF	[Y[HGWZ
TMTQ[ULZDU4E4WXyrq|rmeaaM]Xa]HYHVUa
cTMTQ[ULZDUE4L[JKLPTMTQ[ULZDU4C4aNVF[MK_yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4DLIKUKZ]Gyrq|rmeaaM]XaQVIZMF
UWMPacaNVF[MK_njvwpxqaxwr{ps{444MLIIGOGHOPU_LL_G4_LL_GSF]
TFJD yrq|rmeaaM]XaLYIZQQ_TacaNVF[MK_XYTW[WWPHJQ_RYN[aTSQUDQ
 JLK[4_LL_GIQ[
HR_ D	]I_DOG
yrq|rmeaaM]XaLYIZQQ_TacDLIKUKZ]G_UMYGNJ\RYN[aTSQUDQ
 JLK[44WXWMM[JTMTQ[ULZDUeXYTW[WWPHJQ_cyrq|rmeaaM]Xa]HYHVUa
cTMTQ[ULZDUeD	]I_DOGcE44XQL[_]VTMTQ[ULZDUe_UMYGNJ\c_MLTZU
DL\H NO][QUY[E4WXyrq|rmeaaM]Xa]HYHVUa
cNO][QUY[BByrq|rmeaaM]XaNIR	Ta	acLTZU
DL\HE44]QPJWPK[4C4WXWMM[JTMTQ[ULZDUeSF]
TFJDceLTZU
DL\HceD	]I_DOG	cBByrq|rmeaaM]Xa]HYHVUa
cTMTQ[ULZDUeXYTW[WWPHJQ_ceLTZU
DL\HceRYN[aTSQUDQ
	cE4TMTQ[ULZDUeXYTW[WWPHJQ_ceLTZU
DL\HceIQ[
HR_	c_LL_G4C44XQL[_]VMLIIGOGHOPU_MTaYNFYVYE4TMTQ[ULZDUeRYN[aTSQUDQ
ceLTZU
DL\HceRYN[aTSQUDQ
	cecTaYNFYVY4C4C4C4L[JKLPTMTQ[ULZDU4C44XKP]JWQPRVQ]NMVZXXVX	4E4JLGE4444WXZ[XWP[Z_UMYGNJ\BB]QPMJ_PJSF]
TFJD
	E4L[JKLP4C444WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cRYN[aTSQUDQ
X_RM[E4L[JKLP4C4NYYDLDLQKHXyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP4VHXP[H
FWSZ[XWP[ZSF]
TFJD
inanrkywpazwl44P[UODSJUG	M[FX_LL_G4VHXP[H
FWSD	]I_DOG
4VHXP[H
FWS_UMYGNJ\
4VHXP[H
FWSRYN[aTSQUDQ

44\M_XHFH	O[YL4XQL[_]VP[UODSJUG	M[FX_MJ]YVRPQ[aE4WXJ]YVRPQ[a~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]YVRPQ[a~yrq|rmeaaM]XaXMMOZPIRa
cJ]YVRPQ[aE4\M_XHFH	O[YLJ]YVRPQ[a4444\L[_U4C4C4444WX\M_XHFH	O[YLE4L[JKLP4C444HUQXVUIaZ	Fyrq|rmeaaM]Xa]FMXaRDGSQac\M_XHFH	O[YL444MNRa_KJQRQ_ZaL[YWMJ[LXKP]JWQPVJ]ZYVF_PKM[HUQXVUIaZ	FE4XQL[_]V_LL_GHUQXVUIaZ	FVJ]ZYVF_PSF]
TFJD

HUQXVUIaZ	FVJ]ZYVF_PSF]
TFJD	_MZa]XRFZG
[L[NE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacZa]XRFZG
[L[NE4WP]RKZ[aQP][Za]XRFZG
[L[N4L[JKLP4C4C4C4SJPQN	QR~yrq|rmeaaM]XaHSO\NMa_Da
c\M_XHFH	O[YL4WXSJPQN	QRX_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cSJPQN	QRRYN[aTSQUDQ

X_RM[E4L[JKLP4C4SJPQN	QRyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_
SJPQN	QR4SJPQN	QRyrq|rmeaaM]XaXUWXXXT
OYacD	]I_DOG
IQ[
HR_
	SJPQN	QR4W[NTNLRL
\SPGWN[P	
XIISPKYU[X]PK	S
[D	]I_DOG
4WXW[NTNLRL
\X_RM[E4L[JKLP4C4~yrq|rmeaaM]XaUM_SDP\\\a
cW[NTNLRL
\D	]I_DOG
SJPQN	QR4JLGE4~WP]RKZ[W[NTNLRL
\444CXWP_RRGE4_I	Q]G
P
W[NTNLRL
\4C4MMO_QYLHKFYZyrq|rmeaaM]XaQVIZMF
UWMPacNYYDLDLQKHXnjvwpxqaxwr{ps{44yrq|rme_UMYGNJ\cNYYDLDLQKHX4yrq|rmeRYN[aTSQUDQ
cMMO_QYLHKFYZ4JWWVMO]FD\_UMYGNJ\4D	]I_DOG4RYN[aTSQUDQ

44_UMYGNJ\4IQ[
HR_4C4XYTW[WWPHJQ_	4C4C4IYJ
JUXY[[XNSPGWN[P	
XIISPKYU[X]PK	S
[D	]I_DOG4WXIYJ
JUXY[[XNE4~yrq|rmeaaM]XaUM_SDP\\\a
cIYJ
JUXY[[XNJWWVMO]FD\4JLGE4~WP]RKZ[IYJ
JUXY[[XN4CXWP_RRGE4_I	Q]G
P
IYJ
JUXY[[XN44C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4444QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE44C4C4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4444XKP]JWQPKWMJD	
Q[\a	ZUNPXHJ]LKLVWFPPR]44E444WXyrq|rmeaaM]Xa]HYHVUa
cUNPXHJ]LE4L[JKLPUNPXHJ]L4C444_ZUGHTGKQJOL_LL_GSF]
TFJD_UMYGNJ\_UMYGNJ\RYN[aTSQUDQ

RYN[aTSQUDQ
4XQL[_]V_ZUGHTGKQJOL_MU[GE4WXWMM[JUNPXHJ]LeU[GcBByrq|rmeaaM]Xa]HYHVUa
cUNPXHJ]LeU[GcE4]QPJWPK[4C4VGaX
KNKaFQY_LL_G4444XQL[_]VUNPXHJ]LeU[Gc_MF]XH	HOaFYE444WXyrq|rmeaaM]Xa]HYHVUa
cF]XH	HOaFYE4444VGaX
KNKaFQYecF]XH	HOaFY4]QPJWPK[4C4UX	OTZOF[	ZWMM[JF]XH	HOaFYeRYN[aTSQUDQ

cF]XH	HOaFYeRYN[aTSQUDQ

c4MMO_QYLHKFYZWMM[Jyrq|rmeSF]
TFJDcyrq|rmeXYTW[WWPHJQ_c4WXUX	OTZOF[	ZKLVWFPPR]BBMMO_QYLHKFYZUX	OTZOF[	ZMMO_QYLHKFYZE4]QPJWPK[4C4VGaX
KNKaFQYecKWMJD	
Q[\a	ZF]XH	HOaFYKLVWFPPR]4C44UNPXHJ]LeU[GcVGaX
KNKaFQY4C4L[JKLPUNPXHJ]L444C4444C4XKP]JWQPFKWUXVGDYVWZL4E4WX[SNJGyrq|rme_UMYGNJ\cL[JKLPX_RM[4yrq|rmeXYTW[WWPHJQ_c4L[JKLPJLK[4C44XKP]JWQP_MF[R
JYIFKM4E4JLGE444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
Y[JaJL_PMW[PJ_UMYGNJ\
E4L[JKLP4C4WXFKWUXVGDYVWZLL[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\M[JaJL_PMW[PJRYN[aTSQUDQ
4PLNLa	N[~yrq|rmeaaM]XaNDD_U_S]R\\acXTDWYLRT_NPTYMLP4WXPLNLa	N[PLNLa	N[ 
	PLNLa	N[F[[\[F[]\J

DH]GQG	FQIXTDWYLRT_NPTYMLPE4RNIQ]HK[N~yrq|rmeaaM]Xa_GRUDISIa	cXTDWYLRT_NPTYMLP4KSPWXP]	_UKNRYLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cKSPWXP]	_UKNRGQS[a	
DD\SGLHVKSPWXP]	_UKNRNTVQ
MOI_UDNY[WULRKSPWXP]	_UKNRRINYW\WDWV_QNR
I	E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~]R[_LMJ_J]_]V[JLK[XTDWYLRT_NPTYMLP44WX~yrq|rmeaaM]Xa_GRUDISIa	cXTDWYLRT_NPTYMLPRNIQ]HK[N~yrq|rmeaaM]XaNDD_U_S]R\\acXTDWYLRT_NPTYMLPPLNLa	N[E4444WXTO[]UPZVQVUTYTXTDWYLRT_NPTYMLPG\VSaUWFRZGKSPWXP]	_UKNRE444I_HUSY[\MMDZQUHXTDWYLRT_NPTYMLP4Xa\
Qa\
N_TUXTDWYLRT_NPTYMLP4C4C4C4KPM[JKSPWXP]	_UKNRRNIQ]HK[N4C4QaHKYGPGF\~yrq|rmeaaM]XaNDD_U_S]R\\acXTDWYLRT_NPTYMLP4DPF_\M_QaHKYGPGF\QaHKYGPGF\ 
4WXDPF_\M_QaHKYGPGF\ 
		E4DPF_\M_X_RM[4C4WXDPF_\M_QaHKYGPGF\ 

		TXYNX
	DGPWJNQaHKYGPGF\E4444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4M[JaJL_PMW[PJD	]I_DOG
4C4L[JKLP4C4WXDPF_\M_E4Z_X\F\_FYLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cZ_X\F\_FBBGQS[a	
DD\SGLHVZ_X\F\_FE4DPF_\M_X_RM[4C[RM[E4444N
JNQ	DJKTaHGUOJ[XOIWQXYTW[WWPHJQ_4IHYHGRUH	GNTVQ
MOI_UDNY[WULRZ_X\F\_F4444KLMZZSDZ
NTVQ
MOI_UDNY[WULRyrq|rmeaaM]XaIMI

\G\\a
cN
JNQ	DJKTaHN
JNQ	DJKTaH4WXIHYHGRUH	GKLMZZSDZ
BBH[LMWQPa]QSN_L[KLMZZSDZ
IHYHGRUH	GE4GGNLM	HKyrq|rmeaaM]XaaQKLGJP]_OIacZ_X\F\_F4444\ZW]SL_]	
~yrq|rmeaaM]XaJSJX
DZZNIIJacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_
GGNLM	HK4WX\ZW]SL_]	
E4J]F]NVS[Y[JaQNJWQPSF]
TFJD4WXyrq|rmeaaM]XaIMI

\G\\a
cJ]F]NVS[yrq|rmeaaM]Xa_K_QN_\W	a]a	cJ]F]NVS[GGNLM	HKB\ZW]SL_]	
JLK[4C4WX\ZW]SL_]	
DPF_\M_X_RM[4WX\ZW]SL_]	
yrq|rmeaaM]XaIMI

\G\\a
cN
JNQ	DJKTaHN
JNQ	DJKTaHBBKLMZZSDZ
BBH[LMWQPa]QSN_L[KLMZZSDZ
IHYHGRUH	GSY	]ZUMDJLRRRYN[aTSQUDQ
Z_X\F\_FXYTW[WWPHJQ_	4KPM[JGGNLM	HK\ZW]SL_]	
J]F]NVS[4C[RM[WXyrq|rmeaaM]XaIMI

\G\\a
cN
JNQ	DJKTaHyrq|rmeaaM]XaNJ]SSODDIGGaacN
JNQ	DJKTaH 
yrq|rmeaaM]XaNJ]SSODDIGGaacN
JNQ	DJKTaH	
RKHMW]\JKFVN
JNQ	DJKTaHGQS[a	
DD\SGLHVN
JNQ	DJKTaHyrq|rmeaaM]XaaQKLGJP]_OIacZ_X\F\_Fyrq|rmeaaM]XaaQKLGJP]_OIacN
JNQ	DJKTaHE4DPF_\M_X_RM[4C4C4C4444WXDPF_\M_E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4M[JaJL_PMW[PJSF]
TFJD	
4C4L[JKLP4C444WX\J

DH]GQG	FQIXTDWYLRT_NPTYMLPE4L[JKLP4C4G
aWTHGS[JD
yrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP4WX~yrq|rmeaaM]XaS

	ZLD	a
cG
aWTHGS[JD
E4MO]\DJR_OJ
	ZVVPG
aWTHGS[JD

	JLK[4444C4IDIHaOXFZVOLJGUOJ[XOIWQIQ[
HR_4WXIDIHaOXFZVOLJBByrq|rmeaaM]XaIMI

\G\\a
cIDIHaOXFZVOLJE4WXY[JaJL_PMW[PJRYN[aTSQUDQ
	E4QWVIDDHOPHQ[VKZM_UMYGNJ\	D	]I_DOG	4M[JaJL_PMW[PJXYTW[WWPHJQ_	4C4444C4444WXIDIHaOXFZVOLJyrq|rmeaaM]XaIMI

\G\\a
cIDIHaOXFZVOLJyrq|rmeaaM]XaNJ]SSODDIGGaacIDIHaOXFZVOLJ F]Fyrq|rmeaaM]XaNJ]SSODDIGGaacIDIHaOXFZVOLJ


	RKHMW]\JKFVIDIHaOXFZVOLJGQS[a	
DD\SGLHVIDIHaOXFZVOLJE4RWWNRZTNaMZ	NTVQ
MOI_UDNY[WULRIDIHaOXFZVOLJ4WXRWWNRZTNaMZ	BBH[LMWQPa]QSN_L[RWWNRZTNaMZ	RINYW\WDWV_QNR
I	E4L[JKLP44C4FVMLNQGO_T
Nyrq|rmeaaM]XaaQKLGJP]_OIacIDIHaOXFZVOLJ4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_
FVMLNQGO_T
NL[JKLP4V\JRXLUMOY[JaQNJWQP_UMYGNJ\	
4WXyrq|rmeaaM]XaIMI

\G\\a
cV\JRXLUMOyrq|rmeaaM]Xa_K_QN_\W	a]a	cV\JRXLUMOFVMLNQGO_T
NBL[JKLP4KPM[JFVMLNQGO_T
NV\JRXLUMO4NOL]K\aaJMyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
	yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPD	]I_DOG	4\[LGHV\FG~yrq|rmeaaM]XaJSJX
DZZNIIJacNOL]K\aaJMyrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cNOL]K\aaJM4WX\[LGHV\FGyrq|rmeaaM]XaaQKLGJP]_OIacIDIHaOXFZVOLJ\[LGHV\FGE4L[JKLP4C44Y_HVRRKFFH]X
]VL
RXTDWYLRT_NPTYMLPF]F	4444]NH]XM_
QGTO[]UPZVQVUTYTXTDWYLRT_NPTYMLPG\VSaUWFRZGIDIHaOXFZVOLJ4WX]NH]XM_
QGE4I_HUSY[\MMDZQUHXTDWYLRT_NPTYMLP4Y_HVRRKFFH]X
]VL
RXTDWYLRT_NPTYMLP4Xa\
Qa\
N_TUXTDWYLRT_NPTYMLP4PJYY\WJKRYWPPSJLK[4]_TSGKYNR	aUMMJLK[4Q_XFKXa_[MVSZ	XTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE44M[JaJL_PMW[PJ_UMYGNJ\4C4C[RM[WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD		E4444M[JaJL_PMW[PJD	]I_DOG	4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\	Q	MNQOPFD444C]_J]V{F][NJWQPQ	MNQOPFDE4C4444C44XKP]JWQPQ
UGLSIOGLX]SJQVV4E4UMZ\ZOXL_IJXFQXRYN[aTSQUDQ
	_UMYGNJ\4UMZ\ZOXL_IJXFQXXYTW[WWPHJQ_RYN[aTSQUDQ
4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4L[SQH[a_]JWQPIQ[
HR_
D	]I_DOG4L[SQH[a_]JWQPD	]I_DOGXYTW[WWPHJQ_	

4L[SQH[a_]JWQP_UMYGNJ\SF]
TFJD444C44C4XKP]JWQPTaXD\TPaHWRV4E444JLGE4INZ\yrq|rmeD	]I_DOGc444V[
aHQFFUINZ\ NL[XWFSF]
TFJD4444JSX]LM[U[XTTW
mRYN[aTSQUDQ
INZ\ KM[LM_UMYGNJ\INZ\ KM[LS[J_D	]I_DOG
4IHVL_WNTTINZ\ Y[JaL[MKRJMINZ\ NL[N_L[JSX]LM[U[XTTW
V[
aHQFFUXYTW[WWPHJQ_4WXyrq|rmeaaM]Xa]HYHVUa
cIHVL_WNTTE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
MJLWPYINZ\ R_MJa[LLQL4444L[JKLP_LL_G4C4L[JKLPIHVL_WNTT4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOGQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	Q	MNQOPFD4C4444L[JKLP_LL_G4444C4XKP]JWQPXWHHJI]I
RGHK_JaLKYH_4E4RRaTQ__LL_G4DO_MUHYQSTVXKP]JWQPKYP\VDPJFE4KYP\VDPJFeXYTW[WWPHJQ_c4L[JKLPKYP\VDPJF4C4JLGE4NYDLGXHTQGUOJ[XOIWQRYN[aTSQUDQ
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cNYDLGXHTQNYDLGXHTQ_LL_G4aNZX_RM[444XQL[_]VNYDLGXHTQ_MQGRZYH]OQ HLDNZOZ[	OQLE444WXyrq|rmeaaM]Xa]HYHVUa
cHLDNZOZ[	OQLWMM[JHLDNZOZ[	OQLe]cHLDNZOZ[	OQLe[cyrq|rmeaaM]Xa]HYHVUa
cHLDNZOZ[	OQLe]cWPJHLDNZOZ[	OQLe[c yrq|rmeaaM]XaD]SGTYaFPQHDac		E4RRaTQ_eQGRZYH]OQcHLDNZOZ[	OQLe]c4444C[RM[E4444KPM[JNYDLGXHTQeQGRZYH]OQc4aNZJLK[4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
BByrq|rmeaaM]Xa[	aQ\_KWK[Xa
cIQ[
HR_E4WXaNZSY	]ZUMDJLRRRYN[aTSQUDQ
NYDLGXHTQXYTW[WWPHJQ_	4L[JKLPRRaTQ_4444C4WXyrq|rmeaaM]Xa]HYHVUa
cHK_JaLKYH_BB[SNJGHK_JaLKYH_E4WXaNZSY	]ZUMDJLRRXYTW[WWPHJQ_NYDLGXHTQIQ[
HR_4L[JKLPRRaTQ_44C4FQ\
NM
]yrq|rmeaaM]XaD]SGTYaFPQHDac



4WMaMMRyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
	WMaMMR4]FHSIOLHJLWMaMMRRYN[aTSQUDQ
D	]I_DOG
4JLIPH\OSWQKJYWMaMMRZ[XWP[ZSF]
TFJDm{}kl{akjva}qquw{Z[XWP[ZD	]I_DOGkjva}qquw{4ZO	DU_	\Z[XWP[ZSF]
TFJD	rqyy{zawpa}qquw{4WXJLIPH\OSWQKJYBBZO	DU_	\E4WXaNZSY	]ZUMDJLRR_UMYGNJ\NYDLGXHTQSF]
TFJD4L[JKLPRRaTQ_4444C4P_NJSY\LHHLZ[XWP[ZRYN[aTSQUDQ
}qquw{azqswpyrq|rmeaaM]XaHF	ULKWWW]Zac}qquw{azqswpWWKaQPMV	TTXKZW_GK4QKKPNLHYGaZZ[XWP[Z_UMYGNJ\}qquw{njv4PYUFLGRHR\T
[Z[XWP[ZXYTW[WWPHJQ_zswpa}qquw{anjvIQ[
HR_4P_VFN]LTWMaMMRSF]
TFJDD	]I_DOG
4QIQKFOXaHbJ4444UMZ\ZOXL_IJXFQX_UMYGNJ\DO_MUHYQSTV4NH_HKPZaKDLF[]P
	ON
Z
D	]I_DOG4YNG]KP]Pyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~Y[JaQNJWQPNH_HKPZaKD_LL_G_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cYNG]KP]PYNG]KP]P_LL_G444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4KYZPP[NFR\WPJ~Y[JaQNJWQPLF[]P
	ON
Z
XYTW[WWPHJQ_4WXKYZPP[NFR\E4WX[SNJGYNG]KP]PE4YNG]KP]P_LL_G4~KNZ_J[aQNJWQPNH_HKPZaKDYNG]KP]PSF]
TFJD4C4~KNZ_J[aQNJWQPLF[]P
	ON
Z
SF]
TFJDSF]
TFJD44C4444KPM[JKYZPP[NFR\4C4NJHH_\\HPQyrq|rmeaaM]XaOG\FSVKacRRaTQ_44XQL[_]VHK_JaLKYH__MWQH\VYE4WXyrq|rmeaaM]XaJFVY[	SJPKa	cWQH\VYBBWQH\VY wzBBWQH\VY KM[LaRQYWPE4]QPJWPK[4C4WXNJHH_\\HPQ E44\L[_U4C4MNXTRZQUFMJLWPYWQH\VY KM[LaRQYWP444WXWMM[JRRaTQ_eMNXTRZQUFcE4]QPJWPK[444C4WXWMM[JYNG]KP]PeMNXTRZQUFcWPJYNG]KP]PeMNXTRZQUFc yrq|rmeaaM]XaD]SGTYaFPQHDac

E4]QPJWPK[4444C4INa]_]V[aZ[R[J[WQH\VY wzSF]
TFJD4UK_LWD
_ITaY[JaKM[LaS[J_WQH\VY wzXYTW[WWPHJQ_JLK[4444WXyrq|rmeaaM]Xa]HYHVUa
cUK_LWD
_ITayrq|rmeaaM]XaOG\FSVKacUK_LWD
_ITa 
E4ZKHHGFW	_LL_G4XQL[_]VUK_LWD
_ITa_M\	K	]NH NVZ_MFNX
E4WXWMM[JNVZ_MFNX
eSF]
TFJDcNVZ_MFNX
eSF]
TFJDc yrq|rmeaaM]XaD]SGTYaFPQHDacE4ZKHHGFW	e\	K	]NHcNVZ_MFNX
4C4C444WXyrq|rmeaaM]XaOG\FSVKacZKHHGFW	yrq|rmeaaM]XaOG\FSVKacUK_LWD
_ITaE4KNZ_J[aKM[LaS[J_WQH\VY wzXYTW[WWPHJQ_ZKHHGFW	4C44C4INa]_]V[aZ[R[J[WQH\VY wz_UMYGNJ\4]GWQYTUFOZ]yrq|rmeaaM]XaUQHVIIDGac_LL_G_UMYGNJ\SF]
TFJDWQH\VY wz4[UTQQQQFOLZ]GWQYTUFOZ] ]L[_J[FQ\
NM
]44R	X	SIVS\_LL_G4R	X	SIVS\ecP_NJSY\LHHLQIQKFOXaHXYTW[WWPHJQ_QIQKFOXaHQKKPNLHYGaZQIQKFOXaHP_VFN]LTQIQKFOXaHFQ\
NM
]QIQKFOXaHZO	DU_	\QIQKFOXaHyrq|rmeaaM]Xa]LQPPTVVaJa
cWQH\VY wzFQ\
NM
]IQ[
HR_[UTQQQQFOLZ4WXJLIPH\OSWQKJYE4R	X	SIVS\ecP_NJSY\LHHLQIQKFOXaHSF]
TFJDQIQKFOXaHPYUFLGRHR\T
[QIQKFOXaHP_VFN]LTQIQKFOXaHFQ\
NM
]QIQKFOXaHJLIPH\OSWQKJYQIQKFOXaHyrq|rmeaaM]Xa]LQPPTVVaJa
cWQH\VY wzFQ\
NM
]]FHSIOLHJL[UTQQQQFOLZ4C4RRaTQ_eWQH\VY KM[LaRQYWPcR	X	SIVS\4NYDLGXHTQeMNXTRZQUFc_LL_G] R	X	SIVS\[ FQ\
NM
]4aNZJLK[4NJHH_\\HPQ4C4WXaNZE4SY	]ZUMDJLRR_UMYGNJ\NYDLGXHTQ_UMYGNJ\4C4C]_J]VjVLQI_\R[Q	MNQOPFDE44QWVIDDHOPHQ[VKZMIQ[
HR_	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE44QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	Q	MNQOPFD4C4L[SQH[aXWRJ[LRYN[aTSQUDQ
DO_MUHYQSTV4L[JKLPRRaTQ_4C4XKP]JWQPMR	PFGJMNZ	4E4JLGE4NYDLGXHTQGUOJ[XOIWQRYN[aTSQUDQ
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cNYDLGXHTQBB[SNJGNYDLGXHTQL[JKLP4NH_HKPZaKDLF[]P
	ON
Z
D	]I_DOG4YNG]KP]Pyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~Y[JaQNJWQPNH_HKPZaKD_LL_G_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cYNG]KP]PYNG]KP]P_LL_G44XQL[_]VNYDLGXHTQ_MQGRZYH]OQ HLDNZOZ[	OQLE44YNG]KP]PeQGRZYH]OQcyrq|rmeaaM]Xa]HYHVUa
cHLDNZOZ[	OQLWMM[JHLDNZOZ[	OQLe[cWPJHLDNZOZ[	OQLe[cyrq|rmeaaM]XaD]SGTYaFPQHDac


	4C4XQL[_]VYNG]KP]P_MP]THaNOPTN] MULHDVOPQ_E4WXWPJMULHDVOPQ_yrq|rmeaaM]XaD]SGTYaFPQHDacKPM[JYNG]KP]PeP]THaNOPTN]c4C44WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~KNZ_J[aQNJWQPNH_HKPZaKDYNG]KP]PD	]I_DOG4SY	]ZUMDJLRRXYTW[WWPHJQ__LL_G_UMYGNJ\4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMIQ[
HR_Q	MNQOPFD4C4C4XKP]JWQP\_JFJP[XW[	I[MZL
RLIF]WU444E4444WXyrq|rmeaaM]XaIMI

\G\\a
c[MZL
RLIF]WUL[JKLP[MZL
RLIF]WU4WXyrq|rmeaaM]Xa]HYHVUa
c[MZL
RLIF]WUWMM[J[MZL
RLIF]WUeNcyrq|rmeaaM]XaIMI

\G\\a
c[MZL
RLIF]WUeNcL[JKLP[MZL
RLIF]WUeNc4L[JKLP44C444XKP]JWQPY]	XFTKYURLGHK_JaLKYH_4E4RWMJ_LL_G4DWM
DWXTPaQMJLWPYGUOJ[XOIWQIQ[
HR_44IR\RPRQ
T[Q\NMJLWPYGUOJ[XOIWQSF]
TFJD4WXDWM
DWXTPaQIR\RPRQ
T[Q\NE4RWMJeDWM
DWXTPaQcIR\RPRQ
T[Q\N4C4QKT\WKaTGUOJ[XOIWQXYTW[WWPHJQ_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cQKT\WKaTE4XQL[_]VQKT\WKaT_MTGVRTGYV ]_WR_FWT
E4F_aLRUKPPPL[\_JFJP[XW[	I]_WR_FWT
4WXF_aLRUKPPPL[RWMJeMJLWPYTGVRTGYVcF_aLRUKPPPL[4C4C4L[JKLPRWMJ4C4XKP]JWQPIUUYVSJI[PN]\OMOTGVRTGYV]ZJ\XT		W]	UGFHa	F\D]4E4JLGE4WXyrq|rmeaaM]XaJFVY[	SJPKa	cTGVRTGYVBByrq|rmeaaM]Xa__VX_]O[acTGVRTGYVRYN[aTSQUDQ
E4L[JKLPTGVRTGYV4C4WXTGVRTGYV V_Ma]_NSF]
TFJD	E444L[JKLPTGVRTGYV444C4WXyrq|rmeaaM]XaIMI

\G\\a
cUGFHa	F\D]BBUGFHa	F\D]E4L[JKLPTGVRTGYV4C4QKT\WKaTGUOJ[XOIWQSF]
TFJD
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cQKT\WKaTE4QKT\WKaT_LL_G4C4XQL[_]VQKT\WKaT_MUOFXYWTI GLaSFK[\]aDaE4444MFFWQVHQVyrq|rmeaaM]Xa]HYHVUa
cGLaSFK[\]aDaWMM[JGLaSFK[\]aDae_UMYGNJ\
cWPJGLaSFK[\]aDaeRYN[aTSQUDQ

c4WXMFFWQVHQVMFFWQVHQVyrq|rmeaaM]XaD]SGTYaFPQHDac			KPM[JQKT\WKaTeUOFXYWTIc4C4QKT\WKaTeTGVRTGYV KM[LaRQYWPc_LL_GN UGFHa	F\D]D	]I_DOG
 yrq|rmeaaM]XaD]SGTYaFPQHDacRYN[aTSQUDQ

 4SY	]ZUMDJLRRSF]
TFJDQKT\WKaTD	]I_DOG4444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4444C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD4C4L[JKLPTGVRTGYV4444C4XKP]JWQPNTOOWVaF_Y	
IDKSN
OV	\	NTGVRTGYV4E44JLGE44WXyrq|rmeaaM]XaIMI

\G\\a
cIDKSN
OV	\	NBBIDKSN
OV	\	NL[JKLP4QKT\WKaTGUOJ[XOIWQXYTW[WWPHJQ_	_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cQKT\WKaTBBWMM[JQKT\WKaTeIDKSN
OV	\	NcL[JKLP4Q	MNQOPFDQKT\WKaTeIDKSN
OV	\	Nc4WXyrq|rmeaaM]Xa]HYHVUa
cQ	MNQOPFD[SNJGQ	MNQOPFDeRYN[aTSQUDQ

cE4QKT\WKaTeIDKSN
OV	\	NceRYN[aTSQUDQ

c4SY	]ZUMDJLRRRYN[aTSQUDQ
	QKT\WKaTSF]
TFJD4C4C]_J]VjVLQI_\R[[]\]M_	WU\UZHE4QWVIDDHOPHQ[VKZMSF]
TFJD[]\]M_	WU\UZH444C]_J]V{F][NJWQP[]\]M_	WU\UZHE4QWVIDDHOPHQ[VKZM_UMYGNJ\[]\]M_	WU\UZH4C4C4XKP]JWQP[	W]L[MFVaN\NHK_JaLKYH_4E4444WXyrq|rmeaaM]Xa]HYHVUa
cHK_JaLKYH_E4444L[JKLPX_RM[4C4444_]		a
PWIZFMN[[VOJQTZOHXSGPTZ\4XQL[_]VHK_JaLKYH__MWQH\VYE44XQL[_]V_]		a
PWIZFMN_MKWRORKHVW[E4WXyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_yrq|rmeaaM]XaLYIZQQ_TacKWRORKHVW[XYTW[WWPHJQ_
WQH\VY KM[LaRQYWPE4444L[JKLPWQH\VY4C4C4C4L[JKLPX_RM[4C44XKP]JWQPYFJN
WLK\PYGaHMW
	MFUI		]\4E4L[JKLPyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacYGaHMW
	MFUI		]\444C444XKP]JWQP[]a]TFY
DDKXFUI		]\4E4L[JKLPYFJN
WLK\PKPWOWZMJLWPYyrq|rmeaaM]XaFL_RINU
a
cJLK[FUI		]\4C4444XKP]JWQPHT
TP[QaXSOM[MPNIZPaYMYD_D4E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLPX_RM[4444SLGZ_TWGIDY[JaQNJWQPD	]I_DOG
_LL_G444WXyrq|rmeaaM]Xa]HYHVUa
cSLGZ_TWGIDL[JKLPX_RM[4I	ZLWVK_Iyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_D4WX[SNJGSLGZ_TWGIDeI	ZLWVK_IcL[JKLPX_RM[44F_aLRUKPPPL[yrq|rmeaaM]XaZLWL
M]XJPacBMJLWPYSLGZ_TWGIDeI	ZLWVK_Ic44[KJ
YZDHVWMM[JF_aLRUKPPPL[ecWPJF_aLRUKPPPL[ec4L[JKLP[KJ
YZDHV yrq|rmeaaM]XaD]SGTYaFPQHDac[KJ
YZDHVF	F[[4C4XKP]JWQPZ\P[X]LQWIXI	SMRD[OLKNIZPaYMYD_DVVNTNTX
	YS	TT4E4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_L[JKLP4SLGZ_TWGIDY[JaQNJWQPXYTW[WWPHJQ_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cSLGZ_TWGIDSLGZ_TWGID_LL_G44I	ZLWVK_Iyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_D4WXVVNTNTX
	YS	TTE444WXWMM[JSLGZ_TWGIDeI	ZLWVK_IcE4KPM[JSLGZ_TWGIDeI	ZLWVK_Ic4KNZ_J[aQNJWQPRYN[aTSQUDQ

SLGZ_TWGIDIQ[
HR_4444C4L[JKLP4C444PLX
MHTUP4WX[SNJGSLGZ_TWGIDeI	ZLWVK_IcE4F_aLRUKPPPL[yrq|rmeaaM]XaZLWL
M]XJPacBMJLWPYSLGZ_TWGIDeI	ZLWVK_Ic44PLX
MHTUPWPJF_aLRUKPPPL[ec4C4PLX
MHTUP4[KJ
YZDHVPLX
MHTUP `yrq|rmeaaM]XaD]SGTYaFPQHDac4XQL[_]VSLGZ_TWGID_MQJNXDYVT LSQLY\P]JaT\TLE4aITNP	N]yrq|rmeaaM]XaZLWL
M]XJPacBMJLWPYLSQLY\P]JaT\TL4_K	_I

aWMM[JaITNP	N]ecWPJaITNP	N]ec4WX_K	_I

a[SNJGaITNP	N]ec_K	_I

aWPJaITNP	N]ec4444WX_K	_I

ayrq|rmeaaM]XaD]SGTYaFPQHDac_K	_I

a 	KPM[JSLGZ_TWGIDeQJNXDYVTc4C4SLGZ_TWGIDeI	ZLWVK_IcPLX
MHTUPB[KJ
YZDHVByrq|rmeaaM]XaD]SGTYaFPQHDac444WXyrq|rmeaaM]XaOG\FSVKacSLGZ_TWGID 
E4T\PO\[aV_LL_G4XQL[_]VSLGZ_TWGID_MQJNXDYVT LSQLY\P]JaT\TLE4aITNP	N]yrq|rmeaaM]XaZLWL
M]XJPacBMJLWPYLSQLY\P]JaT\TL4T\PO\[aVeQJNXDYVTcWMM[JaITNP	N]ecWPJaITNP	N]ecWMM[JaITNP	N]ecWPJaITNP	N]ec4C4yrq|rmeaaM]XaORNGZZMPa
cT\PO\[aV4NQXLVJQZyrq|rmeaaM]XaOG\FSVKacSLGZ_TWGID4XQL[_]VT\PO\[aV_MQJNXDYVT FH[\V	KSM_	aME44WXNQXLVJQZ\L[_U444WXQJNXDYVTI	ZLWVK_I]QPJWPK[4KPM[JSLGZ_TWGIDeQJNXDYVTc4444NQXLVJQZ44C4KPM[JT\PO\[aVFH[\V	KSM_	aMNQXLVJQZ4444C44KNZ_J[aQNJWQPD	]I_DOG

SLGZ_TWGID_UMYGNJ\
4444C4XKP]JWQPMWMJQ_	RGHIU]XNIZPaYMYD_DJOTFZUQT	\TO		FFPKRR4E4WXyrq|rmeaaM]XaIMI

\G\\a
cJOTFZUQT	L[JKLP4KPZMJFF[aVSPGWN[P	
XIISPKyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D_UMYGNJ\
444WXKPZMJFF[aVX_RM[E4WX\TO		FFPKRR~yrq|rmeaaM]Xa]]MPGGSWaX]TacKPZMJFF[aV\TO		FF

	4WX~yrq|rmeaaM]XaUM_SDP\\\a
cKPZMJFF[aVJOTFZUQT	yrq|rmeaaM]XaNJ]SSODDIGGaacJOTFZUQT	WWODUHSXYW_HaKPZMJFF[aVNIZPaYMYD_DL[JKLP4_I	Q]G
P
KPZMJFF[aV4C4~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DJOTFZUQT	4C4XKP]JWQPTO[]UPZVQVUTYTNIZPaYMYD_DKRVZ_GODDV4E4ZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D44WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ

	_UMYGNJ\
yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4C4FMIPIXDYTyrq|rmeaaM]Xa[NP\	U	acNIZPaYMYD_D_UMYGNJ\
4WXFMIPIXDYTGQS[a	
DD\SGLHVKRVZ_GODDVE4QWVIDDHOPHQ[VKZM_UMYGNJ\XYTW[WWPHJQ_yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D444L[JKLPX_RM[444C4WXFMIPIXDYTHT
TP[QaXSOM[MPNIZPaYMYD_DL[JKLPX_RM[4QM[XJYMRUYX_RM[4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
cNIZPaYMYD_DQM[XJYMRUYJLK[4JOTFZUQT	PKRR4GY_HOXX_RM[444_\[[GPULRDPKRR4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE4GY_HOXJLK[4WXQM[XJYMRUYE4_\[[GPULRD~XWR[N[LSMNIZPaYMYD_D4WX_\[[GPULRDX_RM[_\[[GPULRDPKRR4C4TKD	JWJTV~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_D4WXTKD	JWJTVX_RM[TKD	JWJTV
	TKD	JWJTV

BBTXYNX
	DGPWJNTKD	JWJTVJOTFZUQT	~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D4KPM[JTKD	JWJTV4444C4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4QWVIDDHOPHQ[VKZMIQ[
HR_RYN[aTSQUDQ
yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4444C4W]DMUTQ\X[DX_RM[4]MUX[WSY]_X_RM[444a]Ryrq|rmeaaM]XaNJ]SSODDIGGaacKRVZ_GODDV4XQLFFQIRVDSM\P[FFFQIRVDSM\P[FFFQIRVDSM\P[FE4W]DMUTQ\X[DSPGWN[P	
XIISPKZFNXLaR
WNWJSW_UMYGNJ\	4WXW]DMUTQ\X[DX_RM[E4]MUX[WSY]_X_RM[4aITNP	N]~yrq|rmeaaM]XaYVI_UURR
OPacW]DMUTQ\X[DIQ[
HR_4444WXaITNP	N]X_RM[E4NH	XIFPVOUK
4IVWR[NH	XIFPVOUK
a]RE4YYIRYMJPONF~yrq|rmeaaM]XaZ
RaK\acaITNP	N]yrq|rmeaaM]Xa[NP\	U	acKRVZ_GODDVNH	XIFPVOUK
444WXYYIRYMJPONFX_RM[BBYYIRYMJPONF\L[_U4NH	XIFPVOUK
YYIRYMJPONF4C4~XXRKMVaITNP	N]4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~XMGP]aITNP	N]4~X]RQM[aITNP	N]4WXNH	XIFPVOUK
a]R]MUX[WSY]_NH	XIFPVOUK
4C[RM[E4]MUX[WSY]_~yrq|rmeaaM]XaUM_SDP\\\a
cW]DMUTQ\X[DKRVZ_GODDV4C4WX]MUX[WSY]_X_RM[]MUX[WSY]_a]R\L[_U444_I	Q]G
P
W]DMUTQ\X[D4444W]DMUTQ\X[DX_RM[44C4C4WXW]DMUTQ\X[DX_RM[E4QWVIDDHOPHQ[VKZMSF]
TFJDIQ[
HR_yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[44C4WX]MUX[WSY]_X_RM[BB]MUX[WSY]_a]RE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ__UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4_I	Q]G
P
W]DMUTQ\X[D4L[JKLPX_RM[4C4WX_\[[GPULRDPKRR~yrq|rmeaaM]Xa]]MPGGSWaX]TacW]DMUTQ\X[D_\[[GPULRD4WXQM[XJYMRUYE444aFSLJL
X	~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DKRVZ_GODDV4WXaFSLJL
X	a]RE4_I	Q]G
P
W]DMUTQ\X[D44~]R[_LMJ_J]_]V[JLK[NIZPaYMYD_D444Q_XFKXa_[MVSZ	NIZPaYMYD_D4WXFMIPIXDYTZ\P[X]LQWIXI	SMRD[OLKNIZPaYMYD_DX_RM[4L[JKLPJLK[4C4WXyrq|rmeaaM]XaIMI

\G\\a
cJOTFZUQT	~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DJOTFZUQT	4_I	Q]G
P
W]DMUTQ\X[D4QWVIDDHOPHQ[VKZMIQ[
HR_	_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4C4MPGO	FQWWODUHSXYW_HaW]DMUTQ\X[DNIZPaYMYD_D4WXMPGO	FQGY_HOXQM[XJYMRUYE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DY_HVRRKFFH]X
]VL
RNIZPaYMYD_D4GFGTITaMMNIZPaYMYD_DSF]
TFJDyrq|rmeaaM]XaFL_RINU
a
c		4WXWWODUHSXYW_HaNIZPaYMYD_DGFGTITaMME4MPGO	FQWWODUHSXYW_HaW]DMUTQ\X[DNIZPaYMYD_D4WXMPGO	FQE44_I	Q]G
P
GFGTITaMM4C[RM[E4444WXWWODUHSXYW_HaGFGTITaMMNIZPaYMYD_DVHSVZMU[ZW\LY_QMUMGFGTITaMMNIZPaYMYD_DE44MWMJQ_	RGHIU]XNIZPaYMYD_DJOTFZUQT	_\[[GPULRD4C4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE4MWMJQ_	RGHIU]XNIZPaYMYD_DJOTFZUQT	_\[[GPULRD4C44C4C444C4WXMPGO	FQQM[XJYMRUYFMIPIXDYTE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DY_HVRRKFFH]X
]VL
RNIZPaYMYD_D44WXVHSVZMU[ZW\LY_QMUMW]DMUTQ\X[DNIZPaYMYD_DE4MPGO	FQJLK[4_I	Q]G
P
W]DMUTQ\X[D4C4C4WXMPGO	FQE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_Da]RE4IN\UPaJ[~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D444WXyrq|rmeaaM]XaIMI

\G\\a
cIN\UPaJ[BByrq|rmeaaM]XaIMI

\G\\a
cJOTFZUQT	IN\UPaJ[JOTFZUQT	E4WXyrq|rmeaaM]XaIMI

\G\\a
cJOTFZUQT	MWMJQ_	RGHIU]XNIZPaYMYD_DJOTFZUQT	_\[[GPULRD4[RM[WXGY_HOX_I	Q]G
P
NIZPaYMYD_D4C4KPM[JIN\UPaJ[4C4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE4MWMJQ_	RGHIU]XNIZPaYMYD_DJOTFZUQT	_\[[GPULRD4C4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
SF]
TFJDyrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4_I	Q]G
P
W]DMUTQ\X[D4L[JKLPX_RM[4C4~]R[_LMJ_J]_]V[JLK[NIZPaYMYD_D4YHMWGSITTX_RM[4444WXa]RF
FX[\	ZE4XRY]FWISL~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D44YHMWGSITTyrq|rmeaaM]XaIMI

\G\\a
cXRY]FWISLyrq|rmeaaM]XaNJ]SSODDIGGaacXRY]FWISLa]Ryrq|rmeaaM]XaaQKLGJP]_OIacXRY]FWISLyrq|rmeaaM]XaaQKLGJP]_OIacKRVZ_GODDV4C[RM[E4]IWUGGJVQyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~V_MVaXWR[RYN[aTSQUDQ
NIZPaYMYD_DX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
c]IWUGGJVQ]IWUGGJVQYHMWGSITT]IWUGGJVQyrq|rmeaaM]XaaQKLGJP]_OIacKRVZ_GODDV4[RM[E4UPQNWWGU[]aF~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_D4WXUPQNWWGU[]aFa]RE4\]HDZ[RJUZTS_P~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRRF]FXX4aLJ~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRRa]R
4YHMWGSITTyrq|rmeaaM]XaIMI

\G\\a
c\]HDZ[RJUZTS_Pyrq|rmeaaM]XaIMI

\G\\a
caLJ\]HDZ[RJUZTS_Pyrq|rmeaaM]Xa[NP\	U	acKRVZ_GODDV
		aLJyrq|rmeaaM]Xa[NP\	U	acKRVZ_GODDVa]R
	4C4C4C4WXYHMWGSITTE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_D	]I_DOG
yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4WXFMIPIXDYTZ\P[X]LQWIXI	SMRD[OLKNIZPaYMYD_DJLK[4WXyrq|rmeaaM]XaIMI

\G\\a
cJOTFZUQT	E4NaUOMM	KJKGGRyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_~V_MVaXWR[IQ[
HR_NIZPaYMYD_DX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cNaUOMM	KJKGGRNaUOMM	KJKGGRNaUOMM	KJKGGRyrq|rmeaaM]XaaQKLGJP]_OIacKRVZ_GODDVNaUOMM	KJKGGRyrq|rmeaaM]XaaQKLGJP]_OIacJOTFZUQT	E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4C4444TRGRLV]ZPHSPGWN[P	
XIISPKZFNXLaR
WNWJSWIQ[
HR_	4WXTRGRLV]ZPHX_RM[~yrq|rmeaaM]XaUM_SDP\\\a
cTRGRLV]ZPHJOTFZUQT	yrq|rmeaaM]XaNJ]SSODDIGGaacJOTFZUQT	E4444~yrq|rmeaaM]Xa]]MPGGSWaX]TacTRGRLV]ZPH_\[[GPULRDPKRR_\[[GPULRD
4WXWWODUHSXYW_HaTRGRLV]ZPHNIZPaYMYD_DE444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DQM[XJYMRUYY_HVRRKFFH]X
]VL
RNIZPaYMYD_D4WXQM[XJYMRUYVHSVZMU[ZW\LY_QMUMTRGRLV]ZPHNIZPaYMYD_DE4_I	Q]G
P
TRGRLV]ZPH4C[RM[E4~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DJOTFZUQT	4_I	Q]G
P
TRGRLV]ZPH4C4C4C[RM[E4WXTRGRLV]ZPHX_RM[_I	Q]G
P
TRGRLV]ZPH4~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DJOTFZUQT	4C4Q_XFKXa_[MVSZ	NIZPaYMYD_D4C[RM[WXGY_HOXE4_I	Q]G
P
NIZPaYMYD_D4C4L[JKLPX_RM[4C44Q_XFKXa_[MVSZ	NIZPaYMYD_D4I_HUSY[\MMDZQUHNIZPaYMYD_D44Y_HVRRKFFH]X
]VL
RNIZPaYMYD_D_\[[GPULRDPKRR_\[[GPULRD
	4WXFMIPIXDYTZ\P[X]LQWIXI	SMRD[OLKNIZPaYMYD_DX_RM[4L[JKLPJLK[4C4XKP]JWQP[DNLN	F]PaLJJFRLKNIZPaYMYD_DSNK	JMF]D
W4E4444DODNOF_PN[NTPVHNVNbP4WXyrq|rmeaaM]XaIMI

\G\\a
cSNK	JMF]D
WSNK	JMF]D
Wyrq|rmeaaM]Xa_K_QN_\W	a]a	cSNK	JMF]D
WD	]I_DOG
X_RM[GQS[a	
DD\SGLHVSNK	JMF]D
WDODNOF_PN[NTPVHSNK	JMF]D
W4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE444aKaPRKX~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D444WXyrq|rmeaaM]XaIMI

\G\\a
caKaPRKXT_DLVDPGFPFPaDQRKaKaPRKXDODNOF_PN[NTPVHL[JKLP4C4WXTO[]UPZVQVUTYTNIZPaYMYD_DDODNOF_PN[NTPVHE4XQW_Ya
[]	K\~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D444WXyrq|rmeaaM]XaIMI

\G\\a
cXQW_Ya
[]	K\T_DLVDPGFPFPaDQRKXQW_Ya
[]	K\DODNOF_PN[NTPVH~yrq|rmeaaM]XaUM_SDP\\\a
cNIZPaYMYD_DDODNOF_PN[NTPVH4KPM[JXQW_Ya
[]	K\4C4Q_XFKXa_[MVSZ	NIZPaYMYD_D4C4XKP]JWQP_XVYTUD_
DPZV]WM4444E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	\LWJOZ[QaDUGL[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	IGGQI[HLH[X]aIFN]LOVL[JKLPJLK[4ZVOP
XVM	_yrq|rmeaaM]XaWFGGDF

Ma
	cyrq|rmeaaM]XaZSHITKKZFa
	c
WPJIGGQI[HLH[X]aIFN]LOV444JFNPOZO]QQVQS[aKLR4JFNPOZO]QQyrq|rmeaaM]Xa_K_QN_\W	a]a	cJFNPOZO]QQX_RM[D	]I_DOG	yrq|rmeaaM]XaD]SGTYaFPQHDacyrq|rmeaaM]XaFL_RINU
a
c		4444ODMWaT]Oa]RLMyrq|rmeaaM]XaZRTJRVaacJLK[4WGIQa[KKMIyrq|rmeaaM]Xa\aLGRF
acJFNPOZO]QQ_LL_GD	]I_DOG		 ZVOP
XVM	_SF]
TFJD X_RM[XYTW[WWPHJQ_ RYN[aTSQUDQ
	 

XYTW[WWPHJQ_	 _LL_GD	]I_DOG	
 XYTW[WWPHJQ_	4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	SF]Q_FWSLT\DJM	yrq|rmeaaM]XaZRTJRVaacJLK[ODMWaT]Oa]RLM4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_		WMaINa[LLQLWGIQa[KKMIE4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	IGGQI[HLH[X]aIFN]LOVL[JKLPJLK[4ZVOP
XVM	_yrq|rmeaaM]XaWFGGDF

Ma
	cyrq|rmeaaM]XaZSHITKKZFa
	cF
FWPJIGGQI[HLH[X]aIFN]LOV4ODMWaT]Oa]RLMyrq|rmeaaM]XaZRTJRVaacJLK[4WGIQa[KKMIyrq|rmeaaM]Xa\aLGRF
acJFNPOZO]QQ_LL_GD	]I_DOG		 ZVOP
XVM	_RYN[aTSQUDQ
	 X_RM[SF]
TFJD IQ[
HR_ 

	SF]
TFJD	 _LL_GSF]
TFJD	
 SF]
TFJD	4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGSF]Q_FWSLT\DJM	yrq|rmeaaM]XaZRTJRVaacJLK[ODMWaT]Oa]RLM4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_		WMaINa[LLQLWGIQa[KKMIL[JKLPX_RM[44C4ZHD	K[P]FWPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[WGIQa[KKMI4L[JKLPZHD	K[P]F F
F
ZHD	K[P]F

	4C4XKP]JWQPRYP[SSJWXJQOMTJZYWa
IUMFM\N]JIV	]XVLK
SK4E4JSX]LM[U[XTTW
yrq|rmeaaM]XaLYIZQQ_Tacyrq|rmeaaM]Xa[KDO
YMUaR\Vac\N]JIV	]XVLK
SK4XQL[_]V4_LL_G4SF]
TFJDJSX]LM[U[XTTW
SF]
TFJD4SF]
TFJD
JSX]LM[U[XTTW
RYN[aTSQUDQ
4XYTW[WWPHJQ_JSX]LM[U[XTTW
XYTW[WWPHJQ_	444_UMYGNJ\4XYTW[WWPHJQ_44_MTIRIMOHaKO4E4WXyrq|rmeaaM]XaIMI

\G\\a
cZYWa
IUMFM\L[_U4ZYWa
IUMFMyrq|rmeaaM]Xa]H[KYS
JDPXa
cTIRIMOHaKObPZYWa
IUMFM4C4L[JKLPZYWa
IUMFM4C4XKP]JWQPQ_XFKXa_[MVSZ	POQNIaLXW4E444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4WX~QN]_]V[aWPH_RWZ_J[POQNIaLXWJLK[X_RM[L[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGL[JKLP\QQR~QN]_]V[aL[M[J4444L[JKLPX_RM[4C4FQZaQ[YYMFyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~QN]_]V[aY[JaMJ_JKMX_RM[X_RM[4L[JKLPyrq|rmeaaM]Xa]HYHVUa
cFQZaQ[YYMF[SNJGFQZaQ[YYMFeXYTW[WWPHJQ_c4C4XKP]JWQPU
]TV\
IZDSUNIZPaYMYD_DUNPXHJ]L_GYZIFZaS444E4WXyrq|rmeaaM]Xa[NP\	U	acNIZPaYMYD_D`_UMYGNJ\
E4WXTO[]UPZVQVUTYTNIZPaYMYD_DUNPXHJ]LE4QWVIDDHOPHQ[VKZM_GYZIFZaSRYN[aTSQUDQ
yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4C4Q_XFKXa_[MVSZ	NIZPaYMYD_D4L[JKLPyrq|rmeaaM]XaNJ]SSODDIGGaacUNPXHJ]L4C4aITNP	N]~yrq|rmeaaM]XaYVI_UURR
OPacNIZPaYMYD_D_UMYGNJ\4WXaITNP	N]X_RM[E4QWVIDDHOPHQ[VKZM_GYZIFZaS_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D4L[JKLPX_RM[4C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
~XRQ]UaITNP	N]rq}ua{f4WGIQa[KKMI~yrq|rmeaaM]XaZ
RaK\acaITNP	N]UNPXHJ]L4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
~XRQ]UaITNP	N]rq}uakp4~X]RQM[aITNP	N]4WXWGIQa[KKMIX_RM[BBUNPXHJ]LWGIQa[KKMIyrq|rmeaaM]XaNJ]SSODDIGGaacUNPXHJ]LE4QWVIDDHOPHQ[VKZM_GYZIFZaSXYTW[WWPHJQ_yrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D444L[JKLPX_RM[4C4L[JKLPWGIQa[KKMI4C44444XKP]JWQPWWQaWD_[]\RT\HNS4E4444JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD		E4J]XS	YI]GXNWTZFPKRR444L[JKLP4C4WXY[JaJL_PMW[PJXYTW[WWPHJQ_	L[JKLP4WXY[JaJL_PMW[PJSF]
TFJDL[JKLP4M[JaJL_PMW[PJRYN[aTSQUDQ
4J]XS	YI]GXNWTZFPKRR4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_Z[R[J[aJL_PMW[PJ_UMYGNJ\4DWM
DWXTPaQyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\MJLWPYGUOJ[XOIWQRYN[aTSQUDQ
4WXDWM
DWXTPaQyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_KM[LP_S[a[FWMJMDWM
DWXTPaQE4M[JaJL_PMW[PJXYTW[WWPHJQ_	4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD44C44C44XKP]JWQPJ]XS	YI]GXNWTZFHK_JaLKYH_4E44WXZPO_XHQ_]L_ZRYN[aTSQUDQ

L[JKLPX_RM[4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGBByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4L[JKLPX_RM[4C4]ZJ\XT		W]	MJLWPYGUOJ[XOIWQRYN[aTSQUDQ
4WX]ZJ\XT		W]	KM[LP_S[a[FWMJM]ZJ\XT		W]	MJLWPYGUOJ[XOIWQIQ[
HR_E4444L[JKLPX_RM[4C44WX]ZJ\XT		W]	E4DWIPWW\YIyrq|rmeaaM]Xa]HYHVUa
cHK_JaLKYH_HK_JaLKYH_TaXD\TPaHWRV4JLa]\	Y[	W]L[MFVaN\NDWIPWW\YI4WX4JLa]\	Y[SNJGJLa]\	Y KM[LaRQYWPWMM[JJLa]\	Y KM[La[S_WR4JLa]\	Y KM[La[S_WRJLa]\	Y KM[LaRQYWP~WWKaQPMV	TTXKZW_GKRYN[aTSQUDQ
44E4]ZJ\XT		W]	MJLWPYJLa]\	Y KM[LaRQYWP4C4C4WX]ZJ\XT		W]	KM[LP_S[a[FWMJM]ZJ\XT		W]	E4IJ		VPYPD[NKM[LP_S[a[FWMJM]ZJ\XT		W]	4UGFHa	F\D][]a]TFY
DDKX4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4444yrq|rmeaaM]XaD\JONRDH[acUGFHa	F\D]IJ		VPYPD[N4C44WXSY	]ZUMDJLRRXYTW[WWPHJQ_]ZJ\XT		W]	_UMYGNJ\
SY	]ZUMDJLRR_UMYGNJ\]ZJ\XT		W]	_UMYGNJ\
4WXSY	]ZUMDJLRRD	]I_DOGUGFHa	F\D]D	]I_DOG
SY	]ZUMDJLRRSF]
TFJDUGFHa	F\D]_UMYGNJ\
4WXMJLWPYGUOJ[XOIWQD	]I_DOG]ZJ\XT		W]	BBMJLWPYGUOJ[XOIWQD	]I_DOGUGFHa	F\D]E4QWVIDDHOPHQ[VKZM_UMYGNJ\XYTW[WWPHJQ_4L[JKLPX_RM[4C4L[JKLPJLK[4444C4_]		a
PWIZFMN[[VOJQTZOHXSGPTZ\4WXJLK[E4]ZJ\XT		W]	44XQLLHFY[X
LRLHFY[X
LR`LHFY[X
LRE4FFQIRVDSM\P[F_]		a
PWIZFMNeyrq|rmeaaM]Xa[PS[FRLVac_]		a
PWIZFMNc[]a]TFY
DDKX	4WXKM[LP_S[a[FWMJMFFQIRVDSM\P[FE4444]ZJ\XT		W]	FFQIRVDSM\P[F4\L[_U4C4444C444WX]ZJ\XT		W]	E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_IQ[
HR_4L[JKLPX_RM[4444C4444C4UGFHa	F\D][]a]TFY
DDKX
4444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
Z[XWP[ZIQ[
HR_yrq|rmeaaM]XaVWRNOHYa]Oa	c|mnjvRYN[aTSQUDQ
E4L[OKWL[aQP][|mnjvD	]I_DOG44C4QUF_[TP]ZJ\XT		W]	~WWKaQPMV	TTXKZW_GK_UMYGNJ\4DPSSHD	\HX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4DPSSHD	\Hyrq|rmeaaM]XaUUN]FI]N
Ia
c_LL_G4D	]I_DOG	 ]ZJ\XT		W]	4SF]
TFJD UGFHa	F\D]44D	]I_DOG QUF_[TP4444SF]
TFJD D	]I_DOG	44RYN[aTSQUDQ
 ]ZJ\XT		W]	44WXWMaINa[LLQLDPSSHD	\HE4QWVIDDHOPHQ[VKZMD	]I_DOGDPSSHD	\H Y[Ja[LLQLa]QZ[DPSSHD	\H Y[Ja[LLQLaS[MM_Y[4DPSSHD	\HX_RM[4C4C4WXDPSSHD	\HE4INZ\WMM[Jyrq|rmeRYN[aTSQUDQ
cyrq|rmeRYN[aTSQUDQ
cPKRR4WXINZ\BByrq|rmeaaM]XaJFVY[	SJPKa	cINZ\E444QWVIDDHOPHQ[VKZMD	]I_DOG_UMYGNJ\4L[JKLPX_RM[4C4VKMIRU[[Nyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
INaV_MVaN_MMIQLZUGFHa	F\D]yrq|rmeaaM]XaaQKLGJP]_OIacUGFHa	F\D]4QZ	HIYJR	HX[Xyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_]KLL[PJaJWS[SF]
TFJDYSZ_J[XYTW[WWPHJQ_	4QMQQ_[
ZLRXHZINZ\ WPM[LJINZ\ KM[LM_LL_G44RYN[aTSQUDQ
	 ]ZJ\XT		W]	4SF]
TFJD VKMIRU[[N4_UMYGNJ\ ]ZJ\XT		W]	4SF]
TFJD QUF_[TP4XYTW[WWPHJQ_ QZ	HIYJR	HX[X4D	]I_DOG 4SF]
TFJD ]ZJ\XT		W]	444_LL_GSF]
TFJDD	]I_DOGD	]I_DOGSF]
TFJD_UMYGNJ\XYTW[WWPHJQ_
RYN[aTSQUDQ
44WXQMQQ_[
ZLRXHZE4QWVIDDHOPHQ[VKZM_UMYGNJ\XYTW[WWPHJQ_4L[JKLPX_RM[4C4DPSSHD	\HWPJINZ\ WPM[LJaWZ4V[
aHQFFUINZ\ NL[XWFSF]
TFJD	4INZ\ WPM[LJINZ\ KM[LS[J__LL_G4D	]I_DOG DPSSHD	\H4D	]I_DOG V[
aHQFFU4IQ[
HR_
 yrq|rmeaaM]XaYQMWZU	ZQPac_LL_GD	]I_DOG	 JLK[444_LL_G_UMYGNJ\
XYTW[WWPHJQ_XYTW[WWPHJQ_4INZ\ WPM[LJINZ\ KM[LS[J__LL_G4_UMYGNJ\ DPSSHD	\H4XYTW[WWPHJQ_ INZ\ NL[XWFIQ[
HR_
4XYTW[WWPHJQ_
 4_LL_GD	]I_DOG
SF]
TFJDD	]I_DOG4444WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\

E4]R[_PaKM[La]_]V[DPSSHD	\H4C4C4WXKM[LP_S[a[FWMJM]ZJ\XT		W]	E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ__UMYGNJ\
4444L[JKLPX_RM[4C4UOFXYWTIyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

Y[JaKM[La\GXYTW[WWPHJQ_
	]ZJ\XT		W]	X_RM[4W_JK[[WTUGX_RM[444WXUOFXYWTI[SNJGUOFXYWTI wzE4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
E4444W_JK[[WTUG\QQRKM[La]_PUOFXYWTI_UMYGNJ\	4C[RM[WXWMM[JUOFXYWTI ]_NMyrq|rmeaaM]Xa]HYHVUa
cUOFXYWTI ]_NME4W_JK[[WTUG[SNJGUOFXYWTI ]_NMeD	]I_DOG	c4C4C4WXW_JK[[WTUGE4QWVIDDHOPHQ[VKZM_UMYGNJ\D	]I_DOG
4WXDPSSHD	\HE4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_Z[XWP[ZRYN[aTSQUDQ
~yrq|rmeaaM]XaVWRNOHYa]Oa	c|mnjvD	]I_DOGE4L[OKWL[aQP][|mnjvD	]I_DOG4C4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~INaZ[R[J[aKM[LDPSSHD	\H4C4L[JKLPX_RM[4C4WXSY	]ZUMDJLRRSF]
TFJD]ZJ\XT		W]	SF]
TFJD
SY	]ZUMDJLRRSF]
TFJD]ZJ\XT		W]	RYN[aTSQUDQ
4WXSY	]ZUMDJLRRXYTW[WWPHJQ_UGFHa	F\D]RYN[aTSQUDQ
SY	]ZUMDJLRRXYTW[WWPHJQ_	UGFHa	F\D]_UMYGNJ\44WXMJLWPYGUOJ[XOIWQRYN[aTSQUDQ
]ZJ\XT		W]	BBMJLWPYGUOJ[XOIWQRYN[aTSQUDQ
	UGFHa	F\D]E4QWVIDDHOPHQ[VKZM_UMYGNJ\RYN[aTSQUDQ
44L[JKLPX_RM[4C444L[JKLPJLK[4C]_J]VjVLQI_\R[Q	MNQOPFDE4444QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4CXWP_RRGE4444FT_Q_YTVaGTRYN[aTSQUDQ

4444C44L[JKLPX_RM[4C444XKP]JWQPPPSVTRGSVXTDY444E444JLGE44WXyrq|rmeaaM]XaJFVY[	SJPKa	cXTDYBBNLQN[LJGa[FWMJMXTDYXYTW[WWPHJQ_E4L[JKLPXTDY4C44]ZJ\XT		W]	yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
MJLWPYGUOJ[XOIWQ_UMYGNJ\4WX]ZJ\XT		W]	E4L[JKLPXTDY4C4444S[YRFLI\P][M]aMOR]ZJ\XT		W]	4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cXTDY OK[LGaIV[L[S[YRFLI\P]X_RM[E4XTDY OK[LGaIV[L[D	]I_DOGS[YRFLI\P]4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOGQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4L[JKLPXTDY4C4XKP]JWQPIUQMRQFFNLVI\NFFON	LW4444E4JLGE4DWM
DWXTPaQyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
MJLWPYGUOJ[XOIWQ_UMYGNJ\4WXDWM
DWXTPaQE4L[JKLPVI\NFFON	LW4C4444DG[JY
QSOG_LL_GIQ[
HR_XYTW[WWPHJQ_	4XQL[_]VDG[JY
QSOG_MU[GE4WXWMM[JVI\NFFON	LWeU[Gcyrq|rmeaaM]XaIMI

\G\\a
cVI\NFFON	LWeU[Gcyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
VI\NFFON	LWeU[Gc]IFHJ	W_ME4PLX
MHTUPyrq|rmeaaM]XaWFGGDF

Ma
	cWPJ]IFHJ	W_Mec4VI\NFFON	LWeU[Gcyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJD	PLX
MHTUPVI\NFFON	LWeU[Gc4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE444C4L[JKLPVI\NFFON	LW4C4XKP]JWQPK_TZ[
SFO[	DMYWQND_SKO	a	FNYVW	WWRNPWZV444E4JLGE4]ZJ\XT		W]	yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
MJLWPYGUOJ[XOIWQ_UMYGNJ\4WX]ZJ\XT		W]	E4L[JKLPYWQND_SKO	a	FNYV4C4WXyrq|rmeaaM]Xa]HYHVUa
cYWQND_SKO	a	FNYVE4L[JKLPYWQND_SKO	a	FNYV4C4WXWMM[JYWQND_SKO	a	FNYVeXYTW[WWPHJQ_cBByrq|rmeaaM]Xa]HYHVUa
cYWQND_SKO	a	FNYVeSF]
TFJDcE4YWQND_SKO	a	FNYVeRYN[aTSQUDQ
c_LL_G4C4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
c]ZJ\XT		W]	YWQND_SKO	a	FNYVeD	]I_DOGcJLK[E4YWQND_SKO	a	FNYVe_UMYGNJ\cec]ZJ\XT		W]	4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4L[JKLPYWQND_SKO	a	FNYV4C444XKP]JWQP[HVS	PaDZNUDND
T4E4PORUXFG_G
I_LL_G44WXZ[XWP[ZXYTW[WWPHJQ_	yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	E4TW	GLXQM
_LL_GY[JaQNJWQPSF]
TFJD	_LL_G4UONF
\QXa	_LL_G4XQL[_]VTW	GLXQM
_M\_M[P_S[E44WXyrq|rmeaaM]XaIMI

\G\\a
c\_M[P_S[BByrq|rmeaaM]Xa_K_QN_\W	a]a	c\_M[P_S[_UMYGNJ\

X_RM[E4]QPJWPK[4C4YFMWRYII\Kyrq|rmeaaM]Xa]FMXaRDGSQac\_M[P_S[444WXYFMWRYII\KE4YFMWRYII\K\_M[P_S[4C4WXWMM[JUONF
\QXa	eYFMWRYII\KcE4]QPJWPK[4C4UONF
\QXa	eYFMWRYII\KcJLK[4NIZPaYMYD_Dinanrkywpazwl\_M[P_S[4WXyrq|rmeaaM]Xa]FMXaRDGSQac\_M[P_S[E4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DE4PORUXFG_G
IecNIZPaYMYD_D4C4C[RM[E4ZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D444WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWE4PORUXFG_G
Iyrq|rmeaaM]XaZOVZW
]WRZLLKa	cPORUXFG_G
IOPVMXNTM\JUaNVZZFNXLaR
WNWJSW_LL_G_UMYGNJ\
	4C44C4C4C44WX~yrq|rmeaaM]XaS

	ZLD	a
c\PQQYLWZWNM]_KPE4]TZJYTNZMQLP]KURFMDRX\PQQYLWZWNM]_KPF]F]4WXyrq|rmeaaM]Xa]HYHVUa
c]TZJYTNZME4XQL[_]V]TZJYTNZM_MDJ
YT\	NFJ[H
E4WXDJ
YT\	NFJ[H
VKYYDIHNYQPMTE4]QPJWPK[4C4POQNIaLXW\PQQYLWZWNM]_KPDJ
YT\	NFJ[H
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacPOQNIaLXWyrq|rmeaaM]XaRJLRacyrq|rmeaaM]XaQVIZMF
UWMPacDJ
YT\	NFJ[H
]QPMJ_PJ_UMYGNJ\	IQ[
HR_	
E4PORUXFG_G
IecPOQNIaLXW4444C4C4C444C44WXZ[XWP[ZIQ[
HR_yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	E444[SW\NVV[]PDMJLWPYY[JaQNJWQPIQ[
HR_	444ZUOLDX[GDHWKHODMJLWPYY[JaQNJWQP_UMYGNJ\		4KYGLRQT	Z[XWP[ZSF]
TFJD	ina}qpj{pjazwlD	]I_DOG	|mnjv_UMYGNJ\	4PYN	aT]\HaOyrq|rmeaaM]XaUYGQMULaFLa
cyrq|rmeaaM]XaV[RJJX\MN
ac_LL_G[SW\NVV[]PDZUOLDX[GDHWKHOD4XQL[_]VPYN	aT]\HaO_MQIQKFOXaHE4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cQIQKFOXaHIQ[
HR_

X_RM[E4444]QPJWPK[4C44VHH_WWH	KYGLRQT	QIQKFOXaH4WX~yrq|rmeaaM]XaS

	ZLD	a
cVHH_WWH	E444FLZPH_ZQLP]KURFMDRXVHH_WWH	4WXyrq|rmeaaM]Xa]HYHVUa
cFLZPH_ZE4XQL[_]VFLZPH_Z_MDJ
YT\	NFJ[H
E4WRLPYN	GWVHH_WWH	DJ
YT\	NFJ[H
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacWRLPYN	GWyrq|rmeaaM]XaRJLRacyrq|rmeaaM]XaQVIZMF
UWMPacDJ
YT\	NFJ[H
]QPMJ_PJIQ[
HR_	D	]I_DOG	
E4PORUXFG_G
IecWRLPYN	GW4C4C444C44444MIDQNRR	IVHH_WWH	D	]I_DOG4WX~yrq|rmeaaM]XaS

	ZLD	a
cMIDQNRR	IE4PORUXFG_G
Iyrq|rmeaaM]XaZOVZW
]WRZLLKa	cPORUXFG_G
IOPVMXNTM\JUaNVZMIDQNRR	I_LL_G_UMYGNJ\4C4C44C4C4L[JKLPyrq|rmeaaM]XaUYGQMULaFLa
cPORUXFG_G
I44C4444XKP]JWQPVLTKTV
SL_KGKFGWWMLIIGOGHOPU4E4WXyrq|rmeaaM]Xa]HYHVUa
cMLIIGOGHOPUL[JKLP_LL_G4VGaX
KNKaFQY_LL_G4XQL[_]VMLIIGOGHOPU_MWGIQa[KKMIE4WXyrq|rmeaaM]XaIMI

\G\\a
cWGIQa[KKMIBBWGIQa[KKMIBByrq|rmeaaM]XaNJ]SSODDIGGaacWGIQa[KKMI 
	
]QPJWPK[4JLGE4444WX~yrq|rmeaaM]Xa_[
SWPR]NacWGIQa[KKMIX_RM[]QPJWPK[4C]_J]VjVLQI_\R[Q	MNQOPFDE44]QPJWPK[4C]_J]V{F][NJWQPQ	MNQOPFDE4]QPJWPK[4C4VGaX
KNKaFQYecWGIQa[KKMI444C4L[JKLPVGaX
KNKaFQY4C444XKP]JWQPI[	P[GJF_NZI[MI]FWMLIIGOGHOPU4E4JLGE44WX[SNJGMLIIGOGHOPUE4L[JKLPX_RM[4C44PORUXFG_G
I[HVS	PaDZNUDND
T4444WX[SNJGPORUXFG_G
IE4L[JKLPX_RM[4C4[UNPT]MY\GGJNJX_RM[4XQL[_]VPORUXFG_G
I_MPOQNIaLXWE44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacPOQNIaLXWBB~yrq|rmeaaM]XaURRZW
ITGa
cPOQNIaLXWE444]QPJWPK[4C44WX~yrq|rmeaaM]XaNDD_U_S]R\\acPOQNIaLXW 
	E444]QPJWPK[4C444KRVZ_GODDV~yrq|rmeaaM]XaHSO\NMa_Da
cPOQNIaLXW444WXKRVZ_GODDVBByrq|rmeaaM]XaIMI

\G\\a
cKRVZ_GODDVE4]QPJWPK[4444C44444QLWQOKMWSLKNOX_RM[4XQL[_]VMLIIGOGHOPU_MaU
ZaWHUFE4JLGE444PMD
IMLUYY]XJ~yrq|rmeaaM]Xa]H[KYS
JDPXa
caU
ZaWHUFKRVZ_GODDV4WXPMD
IMLUYY]XJPKRRPMD
IMLUYY]XJKRVZ_GODDVE4KRVZ_GODDVPMD
IMLUYY]XJ4QLWQOKMWSLKNOJLK[4C4C]_J]VjVLQI_\R[Q	MNQOPFDE44QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD4]QPJWPK[4C]_J]V{F][NJWQPQ	MNQOPFDE4]QPJWPK[4C44C444WXQLWQOKMWSLKNOE4WXTO[]UPZVQVUTYTPOQNIaLXWKRVZ_GODDVE4[UNPT]MY\GGJNJJLK[44C4C4C44L[JKLP[UNPT]MY\GGJNJ444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD444C]_J]V{F][NJWQPQ	MNQOPFDE4C4L[JKLPX_RM[4C4444XKP]JWQPPHS[GV_aSHYaIVJ\HSZFNXLaR
WNWJSWHQP
_Ia[NZ4E4444RRaTQ__LL_G4HQP
_Ia[NZHQP
_Ia[NZ4444KWT	FLOTRUJIQQLP]KURFMDRXZFNXLaR
WNWJSWF\F4WXyrq|rmeaaM]Xa]HYHVUa
cKWT	FLOTRUJIQE4L[JKLPRRaTQ_4C4KWT	FLOTRUJIQyrq|rmeaaM]XaRSVOIDaFHTJacKWT	FLOTRUJIQ
44XQL[_]VKWT	FLOTRUJIQ_MDJ
YT\	NFJ[H
E44WXDJ
YT\	NFJ[H
BBDJ
YT\	NFJ[H
XYTW[WWPHJQ_
E4]QPJWPK[4C44THK[NHGDOKVMRZFNXLaR
WNWJSWDJ
YT\	NFJ[H
4WX~yrq|rmeaaM]XaS

	ZLD	a
cTHK[NHGDOKVMRE44]QPJWPK[4C44WX~yrq|rmeaaM]XaS

	ZLD	a
cTHK[NHGDOKVMRSF]
TFJDE4RRaTQ_ecyrq|rmeaaM]XaNGLV\SLPGacTHK[NHGDOKVMRXYTW[WWPHJQ_444]QPJWPK[4C44WXHQP
_Ia[NZ E444RRaTQ_yrq|rmeaaM]XaZOVZW
]WRZLLKa	cRRaTQ_PHS[GV_aSHYaIVJ\HSTHK[NHGDOKVMRHQP
_Ia[NZ4C4C44L[JKLPRRaTQ_4C4XKP]JWQPL
Y
GVGMNDQOHF4E4QV_D[QLUXGOXS_LL_G4KDD[V__ODyrq|rmeaaM]XaNGLV\SLPGac|mnjv_UMYGNJ\4JLGE4PFZOD
	[DDURKY_LL_G4WXKDD[V__ODE4PFZOD
	[DDURKYecyrq|rmeaaM]Xa]FMXaRDGSQacKDD[V__OD4PFZOD
	[DDURKYecyrq|rmeaaM]Xa]FMXaRDGSQacyrq|rmeaaM]Xa]FMXaRDGSQacKDD[V__OD4PFZOD
	[DDURKYecyrq|rmeaaM]Xa]FMXaRDGSQacyrq|rmeaaM]Xa]FMXaRDGSQacyrq|rmeaaM]Xa]FMXaRDGSQacKDD[V__OD444C444PFZOD
	[DDURKYecD	]I_DOG4PFZOD
	[DDURKYecXYTW[WWPHJQ_4PFZOD
	[DDURKYecSF]
TFJD	4PFZOD
	[DDURKYecSF]
TFJD4PFZOD
	[DDURKYecD	]I_DOG4PFZOD
	[DDURKYecXYTW[WWPHJQ_44PFZOD
	[DDURKYecXYTW[WWPHJQ_44444J	DUZR\VMUyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDMJLWPY~yrq|rmeaaM]Xa[PD\GWFacRYN[aTSQUDQ
4WXJ	DUZR\VMUE4DWNH\JV	I\[yrq|rmeaaM]Xa_K_QN_\W	a]a	cJ	DUZR\VMUX_RM[4XQL[_]Vyrq|rmeaaM]XaZLWL
M]XJPacDWNH\JV	I\[J	DUZR\VMU_MF_aLRUKPPPL[E44F_aLRUKPPPL[yrq|rmeaaM]XaVMQGFWM]acF_aLRUKPPPL[4WXF_aLRUKPPPL[E4PFZOD
	[DDURKYecF_aLRUKPPPL[4C4C4C44PFZOD
	[DDURKYyrq|rmeaaM]XaUYGQMULaFLa
cyrq|rmeaaM]XaV[RJJX\MN
acPFZOD
	[DDURKY4444VLITMYZ	\Q\
NLyrq|rmeaaM]XaZRTJRVaacJLK[4QV_D[QLUXGOXS_LL_G44XQL[_]VPFZOD
	[DDURKY_MZFNXLaR
WNWJSWE44WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWBB~yrq|rmeaaM]XaXMMOZPIRa
cZFNXLaR
WNWJSWE444]QPJWPK[4C4WXyrq|rmeaaM]XaZRTJRVaacJLK[VLITMYZ	\Q\
NL 	E4\L[_U4444C44QV_D[QLUXGOXSyrq|rmeaaM]XaZOVZW
]WRZLLKa	cQV_D[QLUXGOXSPHS[GV_aSHYaIVJ\HSZFNXLaR
WNWJSW4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD444C]_J]V{F][NJWQPQ	MNQOPFDE4C444L[JKLPyrq|rmeaaM]XaaVYPVSS
acyrq|rmeaaM]XaUYGQMULaFLa
cQV_D[QLUXGOXS_LL_GKDD[V__OD4444C4XKP]JWQPZKX\UIUO[FNO][QUY[4E444JLGE4V[RHHJP_LL_GNO][QUY[IQ[
HR_
NO][QUY[_UMYGNJ\4444XQL[_]VV[RHHJP_MZFNXLaR
WNWJSWE4444WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWE4]QPJWPK[4C444aP[NS]QQLP]KURFMDRXZFNXLaR
WNWJSW4WXyrq|rmeaaM]Xa]HYHVUa
caP[NS]QE4]QPJWPK[4C4XQL[_]VaP[NS]Q_MQ	MNQOPFDE4WXyrq|rmeaaM]Xa[NP\	U	acQ	MNQOPFDSF]
TFJDaKIGURZU\I_P
SaFZFNXLaR
WNWJSWQ	MNQOPFD
	E4L[JKLPJLK[4C4C4444XQL[_]VaP[NS]Q_MQ	MNQOPFDE4PQSU]RQIHYZFNXLaR
WNWJSWQ	MNQOPFD444WX~yrq|rmeaaM]XaS

	ZLD	a
cPQSU]RQIHYE44]QPJWPK[4C4[UIHOG[XQLP]KURFMDRXPQSU]RQIHYFZF\4WXyrq|rmeaaM]Xa]HYHVUa
c[UIHOG[XE4]QPJWPK[4C4XQL[_]V[UIHOG[X_MJ]YVRPQ[aE4WXyrq|rmeaaM]Xa[NP\	U	acJ]YVRPQ[aIQ[
HR_aKIGURZU\I_P
SaFPQSU]RQIHYJ]YVRPQ[aF_F][E4L[JKLPJLK[4C4C4C4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOG	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4L[JKLPX_RM[4C4XKP]JWQPIFIYZQDO[JDIQ4E4JLGE4WX\J

DH]GQG	FQIXTDWYLRT_NPTYMLPL[JKLP4444WXY[JaJL_PMW[PJD	]I_DOGE44L[JKLP4C4M[JaJL_PMW[PJXYTW[WWPHJQ_	44XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW
E4L[JKLP4C4WXGQS[a	
DD\SGLHVXaQDFYTWE4QWVIDDHOPHQ[VKZMIQ[
HR_RYN[aTSQUDQ
	
44L[JKLP4C444QV_D[QLUXGOXSL
Y
GVGMNDQOHF4WX[SNJGQV_D[QLUXGOXSE4WXY[JaJL_PMW[PJRYN[aTSQUDQ
E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
_UMYGNJ\4M[JaJL_PMW[PJRYN[aTSQUDQ
FXF	_4C4M[JaJL_PMW[PJRYN[aTSQUDQ
F[XF4L[JKLP4C4N]JOaLXI[I
4XQL[_]VQV_D[QLUXGOXS_MNO][QUY[E44WXZKX\UIUO[FNO][QUY[E444]QPJWPK[444C44NHP[N	HXQJ4_FF[WYX\OGNO][QUY[_UMYGNJ\
4WX~yrq|rmeaaM]XaIWMLWJDNRDPa
c_FF[WYX\OG~yrq|rmeaaM]XaS

	ZLD	a
c_FF[WYX\OGE4_FF[WYX\OGPKRR4C[RM[WX~yrq|rmeaaM]XaS

	ZLD	a
c_FF[WYX\OGE4MO]\DJR_OJ
	ZVVP_FF[WYX\OG	JLK[4C4WX_FF[WYX\OG~yrq|rmeaaM]XaS

	ZLD	a
c_FF[WYX\OGBB~yrq|rmeaaM]XaURRZW
ITGa
c_FF[WYX\OGE44_FF[WYX\OGPKRR4C4WX_FF[WYX\OGE4NUQLL]
a[KM_FF[WYX\OGVKYYDIHNYQPMT4JQZNF][XN[	ODXG\VSaUWFRZGXaQDFYTW4I\KZLXXRXKU
]TV\
IZDSUNUQLL]
a[KMJQZNF][XN[	ODXIQ[
HR_4WXI\KZLXXRXKI\KZLXXRXK yrq|rmeaaM]XaNJ]SSODDIGGaacJQZNF][XN[	ODXE4NHP[N	HXQJNUQLL]
a[KM4C4C4444444WXNHP[N	HXQJE4JIJVIZ\XSayrq|rmeaaM]XaQVIZMF
UWMPacVKYYDIHNYQPMTnjvwpxqaxwr{ps{4MPZJUI_[IOH
NO][QUY[IQ[
HR_JIJVIZ\XSa4WX~yrq|rmeaaM]XaS

	ZLD	a
cMPZJUI_[IOH
E4MO]\DJR_OJ
	ZVVPMPZJUI_[IOH

	
JLK[4C4NUQLL]
a[KMMPZJUI_[IOH
VKYYDIHNYQPMT4JQZNF][XN[	ODXG\VSaUWFRZGXaQDFYTW4I\KZLXXRXKU
]TV\
IZDSUNUQLL]
a[KMJQZNF][XN[	ODXSF]
TFJD4WXI\KZLXXRXKI\KZLXXRXK yrq|rmeaaM]XaNJ]SSODDIGGaacJQZNF][XN[	ODXE44NHP[N	HXQJNUQLL]
a[KM44\_M[P_S[JIJVIZ\XSaVKYYDIHNYQPMT4F[K\JYV]WFGWZXQ[PNO][QUY[\_M[P_S[4C4C4WXNHP[N	HXQJE4]QPJWPK[44C4I_HUSY[\MMDZQUHNHP[N	HXQJ4Y_HVRRKFFH]X
]VL
RNHP[N	HXQJ	4N]JOaLXI[I
4C4WXN]JOaLXI[I
 E4M[JaJL_PMW[PJ_UMYGNJ\4C[RM[E4M[JaJL_PMW[PJXYTW[WWPHJQ_	
4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOGQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C44C4XKP]JWQPF[K\JYV]WFGWZXQ[PNO][QUY[\_M[P_S[4E4JLGE4\IK]FWKX\
DNO][QUY[IQ[
HR_44WX~yrq|rmeaaM]XaJSJX
DZZNIIJac\IK]FWKX\
DE4\IK]FWKX\
Dyrq|rmeaaM]Xa]FMXaRDGSQacNO][QUY[RYN[aTSQUDQ
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac\IK]FWKX\
DE4L[JKLP4C4C4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
c\IK]FWKX\
D4WXDODNOF_PN[NTPVHE4L[JKLP4C4TQO]W
Y	TUI4NL[XWF4WXyrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOGDODNOF_PN[NTPVH]IFHJ	W_ME4TQO]W
Y	TUI]IFHJ	W_Mec4C4WXyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
DODNOF_PN[NTPVH]IFHJ	W_ME4NL[XWF]IFHJ	W_Mec4C4WXTQO]W
Y	TUIBBNL[XWFBByrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_NL[XWFE4L[JKLP4C4INZ\yrq|rmeIQ[
HR_c4WXyrq|rmeaaM]XaJFVY[	SJPKa	cINZ\BByrq|rmeaaM]Xa__VX_]O[acINZ\RYN[aTSQUDQ
E4L[JKLP4C4WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_
TQO]W
Y	TUIE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_			RYN[aTSQUDQ
4L[JKLP4C4444\FMPQNPL[^TQO]W
Y	TUID	]I_DOGNL[XWFIQ[
HR_	4INZ\ OK[LG_UMYGNJ\4UO[RSONWZM\[INZ\ Y[JaH_LmD	]I_DOG\FMPQNPL[RYN[aTSQUDQ
D	]I_DOGD	]I_DOG4WXUO[RSONWZM\[PKRRE4INZ\ OK[LGIQ[
HR_4L[JKLP4C4TW	GLXQM
H[LJQS\YQ_YL\JUO[RSONWZM\[444WXyrq|rmeaaM]Xa]HYHVUa
cTW	GLXQM
E4INZ\ OK[LGD	]I_DOG
4L[JKLP4C4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
c\_M[P_S[TW	GLXQM
JLK[E44INZ\ OK[LGRYN[aTSQUDQ
44L[JKLP4C4TW	GLXQM
ec\_M[P_S[4TW	GLXQM
yrq|rmeaaM]XaY	OD_MOOKGPa
	cTW	GLXQM
44NVZ_MFNX
yrq|rmeaaM]XaYQMWZU	ZQPacTW	GLXQM
4UOFXYWTIINZ\ OK[LGINZ\ NL[N_L[kRYN[aTSQUDQ
\FMPQNPL[SF]
TFJD	SF]
TFJDNVZ_MFNX
4444WXUOFXYWTIX_RM[E4QWVIDDHOPHQ[VKZMSF]
TFJD_UMYGNJ\4INZ\ OK[LGSF]
TFJD4L[JKLP444C44INZ\ OK[LGSF]
TFJD4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4~INa]_]V[aZ[R[J[IQ[
HR_XYTW[WWPHJQ_
444~INa]_]V[aZ[R[J[RYN[aTSQUDQ
	XYTW[WWPHJQ_
4C44C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
Q	MNQOPFD4WXyrq|rmeaaM]XaJFVY[	SJPKa	cyrq|rme_UMYGNJ\cE4~yrq|rmeD	]I_DOGc OK[LGSF]
TFJD4C4444C]_J]V{F][NJWQPQ	MNQOPFDE444QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD4WXyrq|rmeaaM]XaJFVY[	SJPKa	cyrq|rmeXYTW[WWPHJQ_cE4~yrq|rme_UMYGNJ\c OK[LGD	]I_DOG4C4C4C4XKP]JWQPUVLWUT_[UHTD4E4MJ_JW]DODNOF_PN[NTPVHPKRR4WXDODNOF_PN[NTPVHPKRRL[JKLPDODNOF_PN[NTPVH4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	E44DODNOF_PN[NTPVH4L[JKLPDODNOF_PN[NTPVH4444C4DODNOF_PN[NTPVH~YDWPXR_J[yrq|rmeaaM]Xa]HN[Q	\\KPOVacXYTW[WWPHJQ_4444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBByrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVHFF
XDODNOF_PN[NTPVH4L[JKLPDODNOF_PN[NTPVH44C4XKP]JWQPQ[LXV\WRGWDSPZ4E4JLGE4WXZ[XWP[ZSF]
TFJD	L[JKLP4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJD4RNDT\KHO_LYFJN
WLK\P|mnjvD	]I_DOGRYN[aTSQUDQ
4T	QGXDXOS
YFJN
WLK\P|mnjvD	]I_DOG
FF4DISP	RTTNJSyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
]QPJ[PJaKLR4WXDISP	RTTNJSE4444DISP	RTTNJSyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	Y[JaMWJ[aKLRIQ[
HR_
4C4\
FVTHXW]DOZ_yrq|rmeaaM]XaXUWXXXT
OYacXYTW[WWPHJQ_
IQ[
HR_

DISP	RTTNJSRNDT\KHO_L4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c\
FVTHXW]DOZ_XYTW[WWPHJQ_

\
FVTHXW]DOZ_D	]I_DOG

yrq|rmeaaM]XaHF	ULKWWW]Zac\
FVTHXW]DOZ_4aDL]KGYVL]M[yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
VQS[aKLRRYN[aTSQUDQ

DH_PZM_SHORISF]
TFJD
4WXaDL]KGYVL]M[aDL]KGYVL]M[IQ[
HR_

WWKaQPMV	TTXKZW_GKXYTW[WWPHJQ_
	DH_PZM_SHORIRYN[aTSQUDQ

4444WXyrq|rmeaaM]Xa_K_QN_\W	a]a	caDL]KGYVL]M[SF]
TFJD

aDL]KGYVL]M[D	]I_DOG

yrq|rmeaaM]XaHF	ULKWWW]Zacyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\
aDL]KGYVL]M[44FJMGLYVYXJI_J[WMM[Jyrq|rmeIQ[
HR_

cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeRYN[aTSQUDQ


cyrq|rmeXYTW[WWPHJQ_

c4WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[FF
E4FJMGLYVYXJI_J[aZTNULYVSS
]_UMYGNJ\
4C4WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[F[FE4FJMGLYVYXJI_J[UVLWUT_[UHTD4C4JPYSI4WXWMM[Jyrq|rme_UMYGNJ\


cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeIQ[
HR_cyrq|rmeaaM]XaNJ]SSODDIGGaacyrq|rmeSF]
TFJDc 
`E44JPYSIyrq|rmeSF]
TFJDc4C[RM[E444JPYSIaZTNULYVSS
]D	]I_DOG4C444WXyrq|rmeaaM]XaNJ]SSODDIGGaacJPYSI F]FE44SY	]ZUMDJLRRXYTW[WWPHJQ_JPYSISF]
TFJD4C4YaPQ]RNXDJyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
MJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklranjv4WXYaPQ]RNXDJYaPQ]RNXDJ44WXyrq|rmeaaM]Xa[NP\	U	acYaPQ]RNXDJYaPQ]RNXDJ44SRMD
PTW\	JU_LL_G4_UMYGNJ\ FaUJS
PXHWWQFN
\PSW4SF]
TFJD GN_QT]\OPYOaDRP\WV4IQ[
HR_	 YaPQ]RNXDJ4444N	[KF
UHFPH_LL_G4SF]
TFJD \
FVTHXW]DOZ_44XYTW[WWPHJQ_ aGPQ]VFQS_Q444IQ[
HR_ aDL]KGYVL]M[4D	]I_DOG YFJN
WLK\P|mnjvXYTW[WWPHJQ_4D	]I_DOG JPYSI44aDGLZSGUOJ[XOIWQIQ[
HR_	4WXyrq|rmeaaM]XaIMI

\G\\a
caDGLZSBByrq|rmeaaM]XaNJ]SSODDIGGaacaDGLZSE4L[JKLP4C44IFHXTSXaSM
GOyrq|rmeaaM]Xa\	V]W	QFacXZYXWLRYDITOJyrq|rmeaaM]XaZNPRLPO\YVYacN	[KF
UHFPHaDGLZS4VDPDHQ_YU_UMYGNJ\
yrq|rmeaaM]Xa\	V]W	QFacyrq|rmeaaM]XaZNPRLPO\YVYacSRMD
PTW\	JUIQ[
HR_4VDPDHQ_YUSF]
TFJDIFHXTSXaSM
GOXYTW[WWPHJQ_	44NIaQ	J]Hyrq|rmeaaM]XaaQKLGJP]_OIacMJLWPYFJMGLYVYXJI_J[MJLWPYJPYSIaDGLZSyrq|rmeaaM]XaZNPRLPO\YVYacSRMD
PTW\	JUeXYTW[WWPHJQ_cyrq|rmeaaM]XaZNPRLPO\YVYacSRMD
PTW\	JUeD	]I_DOGcByrq|rmeaaM]XaRJLRacWWKaQPMV	TTXKZW_GKBYaPQ]RNXDJ4WXSY	]ZUMDJLRRD	]I_DOGVDPDHQ_YUIQ[
HR_BBaZTNULYVSS
]RYN[aTSQUDQ
VDPDHQ_YUSY	]ZUMDJLRRD	]I_DOG	NIaQ	J]HRYN[aTSQUDQ
4444KPM[JNIaQ	J]H4HSHWXP]
Wyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

VQS[aKLRRYN[aTSQUDQ

DH_PZM_SHORISF]
TFJD
4WXHSHWXP]
WHSHWXP]
WD	]I_DOG

WWKaQPMV	TTXKZW_GKXYTW[WWPHJQ_
	DH_PZM_SHORID	]I_DOG	44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cHSHWXP]
WIQ[
HR_

HSHWXP]
WSF]
TFJD

yrq|rmeaaM]XaHF	ULKWWW]Zacyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\
HSHWXP]
W4SY	]ZUMDJLRRRYN[aTSQUDQ


HSHWXP]
W_UMYGNJ\4WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[
E4L[JKLP4C4444SY	]ZUMDJLRR_UMYGNJ\	FJMGLYVYXJI_J[SF]
TFJD	4WXHP\aHPIQY]M[L[JKLP4F
VNOXGDX\]MGUOK\T\L]4WX~yrq|rmeaaM]XaS

	ZLD	a
cF
VNOXGDX\]MO]\DJR_OJ
	ZVVPF
VNOXGDX\]
	JLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
cF
VNOXGDX\]BB~yrq|rmeaaM]XaURRZW
ITGa
cF
VNOXGDX\]L[JKLP44UMWJ][KYO[WTF
VNOXGDX\]T	QGXDXOS
SF]
TFJD	
4X]GF	T_aNY_XLM	JI
YGTaRGYG[X4XYTW[WWPHJQ_4_LL_Gaamrkyaaaadwnaps{aaaailwj{au{gaaaah{lmwqpaa4_LL_GaGPQ]VFQS_QRNDT\KHO_LYFJN
WLK\P|mnjv_UMYGNJ\FFRINYW\WDWV_QNR
I	44WXX]GF	T_aNY_XE4WXWPJY[JaQNJWQPIQ[
HR_	 QWVIDDHOPHQ[VKZMD	]I_DOG	RYN[aTSQUDQ
	4L[JKLP4C4WX~yrq|rmeaaM]XaVWRNOHYa]Oa	cUMWJ][KYO[WTBByrq|rmeaaM]XaaQKLGJP]_OIacT_DLVDPGFPFPaDQRKMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cUMWJ][KYO[WTyrq|rmeaaM]XaaQKLGJP]_OIacX]GF	T_aNY_XE4U
]TV\
IZDSUUMWJ][KYO[WTX]GF	T_aNY_XD	]I_DOG		4GTOMLTaWMG
IQPG
UMWJ][KYO[WTZQYIVUTIDP[XTYXJ4Y_HVRRKFFH]X
]VL
RUMWJ][KYO[WT		4Xa\
Qa\
N_TUUMWJ][KYO[WT4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPLM	JI
YGTaRGYG[XU[GZXH_XDOHQ
VWUYYWTGIYTT
]G4E44K	G[KIa[HID_TPKRR4WXK	G[KIa[HID_TPKRRE4444K	G[KIa[HID_Tyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	Y[JaJL_PMW[PJNZKPMO\X[I[UX_RM[4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TE4K	G[KIa[HID_THDMHD
OJRSLDGYHSF]
TFJDX_RM[4C4WXyrq|rmeaaM]Xa]HYHVUa
cK	G[KIa[HID_TE4K	G[KIa[HID_T_LL_G4C4C4HPTMOHYaaVNT4WXWMM[JK	G[KIa[HID_TeU[Gcyrq|rmeaaM]XaIMI

\G\\a
cK	G[KIa[HID_TeU[GcE4HPTMOHYaaVNTK	G[KIa[HID_TeU[Gc4C44WXyrq|rmeaaM]XaNJ]SSODDIGGaacHPTMOHYaaVNT`E4HPTMOHYaaVNTaZTNULYVSS
]U[G4C4WXyrq|rmeaaM]XaNJ]SSODDIGGaacHPTMOHYaaVNTFFL[JKLPX_RM[4SJPQN	QRyrq|rmeaaM]Xa]HN[Q	\\KPOVacHPTMOHYaaVNTJLK[4WXSJPQN	QRBByrq|rmeaaM]XaNJ]SSODDIGGaacSJPQN	QRFF_L[JKLPX_RM[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cSJPQN	QRSF]
TFJD
X_RM[L[JKLPX_RM[4SJPQN	QRyrq|rmeaaM]XaXUWXXXT
OYacZXH_XDOHQ
VWUYYWTGIYTT
]GSJPQN	QR4WXZ[XWP[ZRYN[aTSQUDQ


E4JLGE44~JQU[PaY[Ja_RRSJPQN	QRjqu{panlm{4C]_J]VjVLQI_\R[Q	MNQOPFDE4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4L[JKLPX_RM[4C4C[RM[WXGQS[a	
DD\SGLHVSJPQN	QRE444L[JKLPX_RM[44C444L[JKLPSJPQN	QR4C44XKP]JWQPU\IJWaP\LX4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	L[JKLP4WXZ[XWP[ZXYTW[WWPHJQ_	L[JKLP4]SD	MN\[FJZRF	_	WXSP444WX]SD	MN\[E4Q[LXV\WRGWDSPZ4]SD	MN\[FJZRF	_	WXSP4C4ZLU	\GGT[aZTNULYVSS
]D	]I_DOG	4WXyrq|rmeaaM]XaNJ]SSODDIGGaacZLU	\GGT[ZLU	\GGT[yrq|rmeaaM]XaNWFKW[T\a	cbF4Wa[SPWMRVZWMM[Jyrq|rmeIQ[
HR_cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeIQ[
HR_cyrq|rmeaaM]XaNJ]SSODDIGGaacyrq|rmeSF]
TFJDc 
yrq|rmeXYTW[WWPHJQ_caZTNULYVSS
]SF]
TFJD	4WXyrq|rmeaaM]XaNJ]SSODDIGGaacWa[SPWMRVZWa[SPWMRVZUVLWUT_[UHTD444MH[OVTNPTZMWMM[Jyrq|rme_UMYGNJ\cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rme_UMYGNJ\cyrq|rmeaaM]XaNJ]SSODDIGGaacyrq|rme_UMYGNJ\c `
yrq|rme_UMYGNJ\caZTNULYVSS
]SF]
TFJD4]SD\_X]TXHMMyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
MJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklranjv4WX]SD\_X]TXHMM]SD\_X]TXHMM4WXyrq|rmeaaM]Xa[NP\	U	ac]SD\_X]TXHMM]SD\_X]TXHMM4UDFDKXIJDWyrq|rmeaaM]XaaQKLGJP]_OIacWa[SPWMRVZMH[OVTNPTZMZLU	\GGT[yrq|rmeaaM]XaZNPRLPO\YVYacFaUJS
PXHWWQFN
\PSWyrq|rmeaaM]XaZNPRLPO\YVYacGN_QT]\OPYOaDRP\WVByrq|rmeaaM]XaRJLRacWWKaQPMV	TTXKZW_GKB]SD\_X]TXHMM4444KPM[J]SD\_X]TXHMM4WXaZTNULYVSS
]D	]I_DOG	UDFDKXIJDWE444Q[LXV\WRGWDSPZ4]SD	MN\[FJZRF	_	WXSP4C4WXHP\aHPIQY]M[L[JKLP4G
SM	KLTZOJP[HKOPMXO	]LQ4DLOW	P]LPMGP~yrq|rmeaaM]XaVWRNOHYa]Oa	cG
SM	KLTZOJP[HSF]
TFJD4WXDLOW	P]LPMGP]SD	MN\[Y[JaJL_PMW[PJXYTW[WWPHJQ_L[JKLP4Wa
[\I\aIPTUPa444VRaYP_SYVU	D4Ta	J\N
T_KWU	FDG4XY[YLIK
KJTM~yrq|rmeaaM]XaVWRNOHYa]Oa	cG
SM	KLTZOJP[HRYN[aTSQUDQ
4]SD	MN\[FJZRF	_	WXSP4WXXY[YLIK
KJTM]SD	MN\[E4M[JaJL_PMW[PJSF]
TFJD	4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE444C4C4XKP]JWQPVRaYP_SYVU	D4E4JLGE4WXZ[XWP[ZIQ[
HR_	L[JKLP4G
SM	KLTZOJP[HKOPMXO	]LQ4F
VNOXGDX\]MGUOK\T\L]4\N]JIV	]XVLK
SKYFJN
WLK\P|mnjvSF]
TFJD
	XYTW[WWPHJQ_	
44SO_J	P]URyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~yrq|rmeaaM]Xa[PD\GWFacSF]
TFJDX_RM[4SO_J	P]URyrq|rmeaaM]XaIMI

\G\\a
cSO_J	P]URyrq|rmeaaM]XaVMQGFWM]acSO_J	P]UR4WXSO_J	P]URBByrq|rmeaaM]XaIFKVP
MTUFUacSO_J	P]URIQ[
HR_	SO_J	P]URD	]I_DOG4YUIFPJRWUTT
yrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4FNN\	JFXD_Z[XWP[ZIQ[
HR_	ina}qpj{pjazwl_UMYGNJ\YUIFPJRWUTT
4UQD
PKQNQPVTU_LL_Gyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HD	]I_DOGyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPIQ[
HR_yrq|rmeaaM]XaNGLV\SLPGacF
VNOXGDX\]_UMYGNJ\yrq|rmeaaM]XaNGLV\SLPGacYUIFPJRWUTT
XYTW[WWPHJQ_yrq|rmeaaM]XaNGLV\SLPGacFNN\	JFXD_XYTW[WWPHJQ_4WXZ[XWP[ZD	]I_DOG	UQD
PKQNQPVTUecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlD	]I_DOG4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cUQD
PKQNQPVTU_M_JK[	N]VHYQYE4XHYJRKKGK_JK[	N]VHYQY\N]JIV	]XVLK
SK4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXHYJRKKGK[DNLN	F]PaLJJFRLKXHYJRKKGKPKRR4HGD\MWOSJ\QG	V_JK[	N]VHYQYIQ[
HR_\N]JIV	]XVLK
SK4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacHGD\MWOSJ\QG	V[DNLN	F]PaLJJFRLKHGD\MWOSJ\QG	VPKRR444C4KPM[JYUIFPJRWUTT
FNN\	JFXD_UQD
PKQNQPVTU_JK[	N]VHYQYXHYJRKKGKHGD\MWOSJ\QG	V4\OPV[Na_Pa_LL_Gyrq|rmeaaM]XaNGLV\SLPGac|mnjvIQ[
HR_444WXZ[XWP[ZIQ[
HR_\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlSF]
TFJD4\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HD	]I_DOG
4\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPSF]
TFJD
4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
c\OPV[Na_Pa_MGVRaJQOT	KPE4HZ]T
XY_SGVRaJQOT	KPSO_J	P]UR4Ga[XY]SZX	R~yrq|rmeaaM]XaJSJX
DZZNIIJacHZ]T
XY_S~yrq|rmeaaM]XaHSO\NMa_Da
cHZ]T
XY_S4WXyrq|rmeaaM]XaIMI

\G\\a
cGa[XY]SZX	RBBGa[XY]SZX	RBByrq|rmeaaM]Xa_K_QN_\W	a]a	cGa[XY]SZX	R\N]JIV	]XVLK
SKX_RM[]QPJWPK[4[\GRHVaYa\_yrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\yrq|rmeaaM]XaLYIZQQ_Tac\N]JIV	]XVLK
SKD	]I_DOGbPGa[XY]SZX	R4WXyrq|rmeaaM]XaIMI

\G\\a
c[\GRHVaYa\_[\GRHVaYa\_Ga[XY]SZX	RTO[]UPZVQVUTYTHZ]T
XY_S[\GRHVaYa\_QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	RYN[aTSQUDQ
4444C4444KPM[J\OPV[Na_PaGVRaJQOT	KPHZ]T
XY_SGa[XY]SZX	R[\GRHVaYa\_4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4~Z[R[J[aQNJWQPRYN[aTSQUDQ
4~Z[R[J[aQNJWQPRYN[aTSQUDQ
4444~Z[R[J[aQNJWQPSF]
TFJD4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOG	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE444C4C4XKP]JWQPRM[_\YODRQDD\Z_VL4E4JLGE444WXZ[XWP[ZIQ[
HR_L[JKLP4G
SM	KLTZOJP[HKOPMXO	]LQ444F
VNOXGDX\]MGUOK\T\L]44\N]JIV	]XVLK
SKYFJN
WLK\P|mnjv_UMYGNJ\
RYN[aTSQUDQ
	
44YUIFPJRWUTT
yrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
4FNN\	JFXD_Z[XWP[ZSF]
TFJDina}qpj{pjazwl_UMYGNJ\YUIFPJRWUTT
444UQD
PKQNQPVTU_LL_Gyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HRYN[aTSQUDQ
yrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_yrq|rmeaaM]XaNGLV\SLPGacF
VNOXGDX\]RYN[aTSQUDQ
yrq|rmeaaM]XaNGLV\SLPGacYUIFPJRWUTT
RYN[aTSQUDQ
yrq|rmeaaM]XaNGLV\SLPGacFNN\	JFXD_SF]
TFJD44WXZ[XWP[ZD	]I_DOG	UQD
PKQNQPVTUecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlSF]
TFJD4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cUQD
PKQNQPVTU_M_JK[	N]VHYQYE4OR_JY	SF[MP_JK[	N]VHYQY\N]JIV	]XVLK
SK4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacOR_JY	SF[MP[DNLN	F]PaLJJFRLKOR_JY	SF[MPPKRR4C4KPM[JYUIFPJRWUTT
FNN\	JFXD_UQD
PKQNQPVTU_JK[	N]VHYQYOR_JY	SF[MP4UZ[]YPT\_LL_Gyrq|rmeaaM]XaNGLV\SLPGac|mnjvRYN[aTSQUDQ
4WXZ[XWP[ZRYN[aTSQUDQ
	UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlD	]I_DOG44UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[H_UMYGNJ\4UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cUZ[]YPT\_MKK\XLGL_\E4HGD\MWOSJ\QG	VKK\XLGL_\_UMYGNJ\4[WQHV[F\~yrq|rmeaaM]XaJSJX
DZZNIIJacHGD\MWOSJ\QG	V~yrq|rmeaaM]XaHSO\NMa_Da
cHGD\MWOSJ\QG	V4WXyrq|rmeaaM]XaIMI

\G\\a
c[WQHV[F\BB[WQHV[F\BByrq|rmeaaM]Xa_K_QN_\W	a]a	c[WQHV[F\\N]JIV	]XVLK
SKX_RM[]QPJWPK[4444VaXRRDMPFIPKRYP[SSJWXJQOMTJ[WQHV[F\\N]JIV	]XVLK
SK4WXyrq|rmeaaM]XaIMI

\G\\a
cVaXRRDMPFIPKVaXRRDMPFIPK[WQHV[F\TO[]UPZVQVUTYTHGD\MWOSJ\QG	VVaXRRDMPFIPKQWVIDDHOPHQ[VKZMRYN[aTSQUDQ
IQ[
HR_4C4KPM[JUZ[]YPT\KK\XLGL_\HGD\MWOSJ\QG	V[WQHV[F\VaXRRDMPFIPK4WXyrq|rmeaaM]XaFOMVMVNG[KNac_UMYGNJ\
L[JKLP4WXMNORNW	VPL[JKLP4WXHP\aHPIQY]M[L[JKLP4JJQU]F]_S[F
VNOXGDX\]D	]I_DOG4MLIIGOGHOPUSF]
TFJDbP4SF]
TFJDbPXYTW[WWPHJQ_
bPD	]I_DOGbP4444D	]I_DOGbP_UMYGNJ\	bPD	]I_DOGbP4RYN[aTSQUDQ
bP4444HUVO]D_TFI	~yrq|rmeaaM]XaVWRNOHYa]Oa	cJJQU]F]_S[4]KLL[PJHUVO]D_TFI	~yrq|rmeaaM]XaHSO\NMa_Da
cJJQU]F]_S[4444WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZM_UMYGNJ\IQ[
HR_4L[JKLP4C4MGTa

MIRGPD]_LL_Gyrq|rmeaaM]XaNGLV\SLPGac|mnjvD	]I_DOG4WXZ[XWP[ZRYN[aTSQUDQ
MGTa

MIRGPD]ecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlSF]
TFJD4WXZ[XWP[ZRYN[aTSQUDQ
MGTa

MIRGPD]ecyrq|rmeaaM]XaNGLV\SLPGacinskanrkywpazwlXYTW[WWPHJQ_4WXZ[XWP[Z_UMYGNJ\	MGTa

MIRGPD]ecyrq|rmeaaM]XaNGLV\SLPGacinanrkywpazwlSF]
TFJD44MKWDYPZDLyrq|rmeaaM]XaNGLV\SLPGacF
VNOXGDX\]XYTW[WWPHJQ_4]]RNWKZNyrq|rmeaaM]Xa_LHMQPFPD
Ma
cMKWDYPZDLMGTa

MIRGPD]JLK[4KPM[JMGTa

MIRGPD]MKWDYPZDL4WX]]RNWKZNE4]XZ_RI\_DTJOF
VNOXGDX\]XYTW[WWPHJQ_
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac]XZ_RI\_DTJOU
]TV\
IZDSU]XZ_RI\_DTJOD	]I_DOG4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJ_UMYGNJ\X_RM[E4SJaSY
PHP]KLL[PJ4WX]KLL[PJyrq|rmeaaM]Xa[NP\	U	ac]KLL[PJbP]KLL[PJbP4KSPWXP]	_UKNR~yrq|rmeaaM]XaHSO\NMa_Da
cJJQU]F]_S[44WXyrq|rmeaaM]XaIMI

\G\\a
cKSPWXP]	_UKNRKSPWXP]	_UKNR4WXKSPWXP]	_UKNRSJaSY
PHPE4QWVIDDHOPHQ[VKZMSF]
TFJDXYTW[WWPHJQ_	4C[RM[E4TO[]UPZVQVUTYTJJQU]F]_S[]KLL[PJMLIIGOGHOPU4444GTOMLTaWMG
IQPG
JJQU]F]_S[ZQYIVUTIDP[XTYXJ4WXHUVO]D_TFI	Y_HVRRKFFH]X
]VL
RJJQU]F]_S[	

4C44KPM[JKSPWXP]	_UKNRSJaSY
PHP444C4C4KPM[J]]RNWKZN]XZ_RI\_DTJOHUVO]D_TFI	444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD444C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD4C4444C4XKP]JWQPFVRRPN
U	PaP
4E4JLGE4WXZ[XWP[Z_UMYGNJ\L[JKLP4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	L[JKLP4YKYRaNa

UYFJN
WLK\P|mnjvSF]
TFJD	4XaQDFYTWPJYY\WJKRYWPPS44WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW
L[JKLP4HPTMOHYaaVNT]_TSGKYNR	aUMM444]KLL[PJ~Y[JaQNJWQPYKYRaNa

U4WX]KLL[PJyrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJyrq|rmeaaM]XaNJ]SSODDIGGaacHPTMOHYaaVNT]KLL[PJHPTMOHYaaVNTL[JKLP4444WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4KNZ_J[aQNJWQPYKYRaNa

UHPTMOHYaaVNTD	]I_DOG4C[RM[WXZ[XWP[ZRYN[aTSQUDQ
Z[XWP[ZIQ[
HR_Z[XWP[ZD	]I_DOGZ[XWP[ZRYN[aTSQUDQ
yrq|rmeaaM]Xa[	aQ\_KWK[Xa
cD	]I_DOG
E4V	OW_F_UPT[\XYTW[WWPHJQ_4JZPWFXDFHH~P[IV	OW_F_UPT[\]QPMJ_PJSF]
TFJD]QPMJ_PJSF]
TFJD]QPMJ_PJSF]
TFJD]QPMJ_PJRYN[aTSQUDQ
4WXJZPWFXDFHHJZPWFXDFHH ]QPP[]Ja[LLPQE4NL[XWFWMM[Jyrq|rmeXYTW[WWPHJQ_c NL[XWFyrq|rmeRYN[aTSQUDQ
c NL[XWFXYTW[WWPHJQ_44D
MNUDZYJZPWFXDFHH L[_Ra[M]_N[aMJLWPYHPTMOHYaaVNT4OIIJH		JZPWFXDFHH L[_Ra[M]_N[aMJLWPYYKYRaNa

U4JZPWFXDFHH OK[LGwpbFbF
ljbF
pbF
qENL[XWFCQNbF	
bFbFXbF[MbFXbF	bF	
bFbFXbF[abF[_SbFQNJbFbFXPaH_RKbF_KJQbF]Q_ZbFbF
bF
]kbF
bFEOIIJH		CED
MNUDZYCPbFXbF
XbF
[zknrw}bF
{bF
\{gbFbFzbF
j{QbF	JWQbF[aH_bF]K[ED
MNUDZYC4WXJZPWFXDFHH [LLQLQWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	SF]
TFJDyrq|rmeaaM]Xa[NP\	U	acJZPWFXDFHH [LLQL	`4JZPWFXDFHH ]RQM[4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPK[UTJVF[HGFKQRY4E44DDTORYQH[[FN]PZ[XWP[ZIQ[
HR_ina}qpj{pjazwl|mnjvXYTW[WWPHJQ_4SGDQ_VIHJ
XIMRYFJN
WLK\P|mnjvIQ[
HR_4L[JKLP_LL_GDDTORYQH[[FN]P_UMYGNJ\DDTORYQH[[FN]P_UMYGNJ\
SGDQ_VIHJ
XIMRIQ[
HR_
SGDQ_VIHJ
XIMR4C4XKP]JWQPJRHID\D	OYV[THYKIGKa4E4MQ]aVRO]HH\WPJ~yrq|rmeaaM]XaNDD_U_S]R\\acYV[THYKIGKa4WXMQ]aVRO]HH\FF]BBMQ]aVRO]HH\ 		L[JKLPX_RM[44TLRJLFQGaU[T~yrq|rmeaaM]XaHSO\NMa_Da
cYV[THYKIGKa4WXyrq|rmeaaM]XaIMI

\G\\a
cTLRJLFQGaU[TBByrq|rmeaaM]XaNJ]SSODDIGGaacTLRJLFQGaU[TBByrq|rmeaaM]XaNJ]SSODDIGGaacTLRJLFQGaU[T 	
L[JKLPX_RM[4F_aLRUKPPPL[yrq|rmeaaM]XaZLWL
M]XJPacTLRJLFQGaU[T	4WXyrq|rmeaaM]XaOG\FSVKacF_aLRUKPPPL[BBF_aLRUKPPPL[ec_UMYGNJ\
BByrq|rmeaaM]XaNJ]SSODDIGGaacF_aLRUKPPPL[ecL[JKLPX_RM[4KSZ
H	MT
H~yrq|rmeaaM]Xa]HN[Q	\\KPOVacF_aLRUKPPPL[ec4WXKSZ
H	MT
HX_RM[BByrq|rmeaaM]XaNJ]SSODDIGGaacKSZ
H	MT
HF
F[L[JKLPX_RM[4WXyrq|rmeaaM]Xa[NP\	U	acKSZ
H	MT
HbFXbF\E4SW_ZSZVGXa~yrq|rmeaaM]XaQXZTaR[L
VQOa		chyrq|rmeaaM]Xa[NP\	U	acKSZ
H	MT
H
`
4WXyrq|rmeaaM]Xa]HYHVUa
cSW_ZSZVGXaBBSW_ZSZVGXaecBBSW_ZSZVGXaec 
	
L[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

KSZ
H	MT
H~YDZ[]QZ[KSZ
H	MT
H
4[RM[WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4KSZ
H	MT
H~YDWPXR_J[yrq|rmeaaM]Xa[NP\	U	acKSZ
H	MT
HF	Fyrq|rmeaaM]XaNJ]SSODDIGGaacKSZ
H	MT
H`	

4WXyrq|rmeaaM]XaIMI

\G\\a
cKSZ
H	MT
Hyrq|rmeaaM]XaNJ]SSODDIGGaacKSZ
H	MT
H 
L[JKLPX_RM[4C[RM[L[JKLPX_RM[4C44WXyrq|rmeaaM]XaIMI

\G\\a
cKSZ
H	MT
HBByrq|rmeaaM]XaNJ]SSODDIGGaacKSZ
H	MT
HBByrq|rmeaaM]Xa[NP\	U	acKSZ
H	MT
H
_UMYGNJ\	BByrq|rmeaaM]XaaQKLGJP]_OIacKSZ
H	MT
HF_aLRUKPPPL[ecL[JKLPX_RM[4L[JKLPKSZ
H	MT
H4C4XKP]JWQPPZUa[	RS]U4E4JLGE4WXZ[XWP[ZSF]
TFJD

L[JKLP4_HM]VRVP_
YK[UTJVF[HGFKQRY4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac_HM]VRVP_
YecL[JKLP44WXJRHID\D	O_HM]VRVP_
YecX_RM[L[JKLP4SJPQN	QRLM	JI
YGTaRGYG[XD	]I_DOG
_LL_Gaamrkyaa_LL_Gyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPIQ[
HR_	
4WXyrq|rmeaaM]XaIMI

\G\\a
cSJPQN	QRBBSJPQN	QRL[JKLP4SJPQN	QRyrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_
SJPQN	QR4WXyrq|rmeaaM]XaIMI

\G\\a
cSJPQN	QRBBSJPQN	QRL[JKLP44DX_
ZZZ	OLRORINYW\WDWV_QNR
I	YFJN
WLK\P|mnjvXYTW[WWPHJQ_
4G
GDOHVVHPLXSF]
TFJD
	DX_
ZZZ	OLROIQ[
HR_
4GLaSFK[\]aDaXYTW[WWPHJQ_
DX_
ZZZ	OLROD	]I_DOG4TSQUPTHRGTSXYTW[WWPHJQ__HM]VRVP_
Yec_UMYGNJ\RINYW\WDWV_QNR
I	D	]I_DOGbPSJPQN	QR4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac_HM]VRVP_
YecE4444WXGXLa_NLOL_P_HM]VRVP_
YecE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
_UMYGNJ\4L[JKLP4C4WXTO[]UPZVQVUTYT_HM]VRVP_
YecTSQUPTHRGTSE4GTOMLTaWMG
IQPG
_HM]VRVP_
YecZQYIVUTIDP[XTYXJ4444Y_HVRRKFFH]X
]VL
R_HM]VRVP_
Yec
4Xa\
Qa\
N_TU_HM]VRVP_
Yec4WUUIP	M_XOZKJ	YHT_HM]VRVP_
Yec4C4444L[JKLP4444C4\GWP[WUJHGRN~yrq|rmeaaM]XaHSO\NMa_Da
c_HM]VRVP_
Yec4WXyrq|rmeaaM]XaIMI

\G\\a
c\GWP[WUJHGRNBByrq|rmeaaM]XaNJ]SSODDIGGaac\GWP[WUJHGRN FX	
F		]L[JKLP4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c\GWP[WUJHGRNG
GDOHVVHPLXX_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	c\GWP[WUJHGRNGLaSFK[\]aDaX_RM[L[JKLP44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c\GWP[WUJHGRND	]I_DOG
X_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	c\GWP[WUJHGRNRYN[aTSQUDQ
_HM]VRVP_
YecX_RM[E4WXyrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJDyrq|rmeaaM]Xa[NP\	U	ac\GWP[WUJHGRN
MOFOIYDZIIFOH[LMWQPa]QSN_L[MOFOIYDZIIFOecRINYW\WDWV_QNR
I	_UMYGNJ\L[JKLP4WXGXLa_NLOL_P_HM]VRVP_
Yec\GWP[WUJHGRNE4QWVIDDHOPHQ[VKZM_UMYGNJ\_UMYGNJ\	4L[JKLP44C4444WXTO[]UPZVQVUTYT_HM]VRVP_
YecTSQUPTHRGTSE4GTOMLTaWMG
IQPG
_HM]VRVP_
YecZQYIVUTIDP[XTYXJ4Y_HVRRKFFH]X
]VL
R_HM]VRVP_
YecF
F4Xa\
Qa\
N_TU_HM]VRVP_
Yec4WUUIP	M_XOZKJ	YHT_HM]VRVP_
Yec4C4L[JKLP4C4444]WRDLZN
	H
	WYFJN
WLK\P|mnjv_UMYGNJ\	4\GWP[WUJHGRNyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJD]WRDLZN
	H
	WD	]I_DOG\GWP[WUJHGRN4444WXyrq|rmeaaM]XaIMI

\G\\a
c\GWP[WUJHGRNE4QWVIDDHOPHQ[VKZM_UMYGNJ\_UMYGNJ\4L[JKLP4C4WX~yrq|rmeaaM]XaURRZW
ITGa
c_HM]VRVP_
YecL[JKLP4WXOYRGP[M
J]UHJF]Ra
_UMYGNJ\E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_RYN[aTSQUDQ
4L[JKLP4C4WXGXLa_NLOL_P_HM]VRVP_
Yec\GWP[WUJHGRNE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
XYTW[WWPHJQ_	4L[JKLP444C4HDZZFLJaIRTM\QSLDPNXYTW[WWPHJQ_
44LGLZ_UYa
G
GDOHVVHPLXbP_UMYGNJ\_HM]VRVP_
Yec_UMYGNJ\bPSJPQN	QRbPGLaSFK[\]aDa4WXTO[]UPZVQVUTYT_HM]VRVP_
YecYaHGZ[[LY_
\GWP[WUJHGRNLGLZ_UYa
E44WUUIP	M_XOZKJ	YHT_HM]VRVP_
Yec4Xa\
Qa\
N_TU_HM]VRVP_
Yec4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMIQ[
HR_
Q	MNQOPFD444C]_J]V{F][NJWQPQ	MNQOPFDE4C4C44XKP]JWQPHH_aKX\ZVJXVL]Y4E4JLGE4WXZ[XWP[ZXYTW[WWPHJQ_

L[JKLP4_HM]VRVP_
YK[UTJVF[HGFKQRY4TXWDIFQUaLTUR]MJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c_HM]VRVP_
YecX_RM[PKRR4444WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_TXWDIFQUaLTUR]]IFHJ	W_M]IFHJ	W_MecRINYW\WDWV_QNR
I	E4DHZD\WGRaDMMOWPJY[JaQNJWQPXYTW[WWPHJQ_	4WXyrq|rmeaaM]XaD]SGTYaFPQHDacDHZD\WGRaDMMO
L[JKLP4WXJRHID\D	O_HM]VRVP_
YecX_RM[E4~KNZ_J[aQNJWQPXYTW[WWPHJQ_yrq|rmeaaM]XaD]SGTYaFPQHDacXYTW[WWPHJQ_444L[JKLP4C44QWVIDDHOPHQ[VKZM_UMYGNJ\
_UMYGNJ\	44C4XaQDFYTWPJYY\WJKRYWPPS44WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW
	BByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW F
X
\F\\BBGQS[a	
DD\SGLHVXaQDFYTWL[JKLP44PHIMQXUFVyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	~YD[P]QZ[XaQDFYTW
XaQDFYTW4WXyrq|rmeaaM]XaIMI

\G\\a
cPHIMQXUFVBBPHIMQXUFVL[JKLP4WXTO[]UPZVQVUTYT_HM]VRVP_
YecXYTW[WWPHJQ_	RINYW\WDWV_QNR
I	yrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWyrq|rmeaaM]Xa\	V]W	QFacPHIMQXUFV~KNZ_J[aQNJWQPSF]
TFJDyrq|rmeaaM]XaD]SGTYaFPQHDacIQ[
HR_4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPQWMZ
HN]OGMKVDOXa	4E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	L[JKLPX_RM[4NGKJDX
JYMZ[XWP[ZSF]
TFJD	~yrq|rmeaaM]XaVWRNOHYa]Oa	c|mnjvSF]
TFJD|mnjvD	]I_DOGaaxwr{aa4L[JKLPyrq|rmeaaM]XaXKPX_GDYIMa	cNGKJDX
JYMM4C4XKP]JWQPKSKH
FYRM]\XLGaW]K4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	
BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	L[JKLP4WXZ[XWP[ZSF]
TFJD	L[JKLP4XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW	L[JKLP4U[GQWMZ
HN]OGMKVDOXa	4WXU[GX_RM[L[JKLP4K	SV
XD
SM\Q[[yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG		yrq|rmeaaM]XaHMU
XNXMKa		cIQ[
HR_	XaQDFYTWyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTW4K	G[KIa[HID_TXYTW[WWPHJQ_	yrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTWK	SV
XD
SM\Q[[bPXaQDFYTW4KIPWOKK	
UJI[Kyrq|rmeaaM]XaNJ]SSODDIGGaacK	G[KIa[HID_T4\KTRQO	~yrq|rmeaaM]XaPP_MVXQR[a	
cU[G_4WX\KTRQO	E4QaHKYGPGF\WPJ~yrq|rmeaaM]XaDFQaWHVac\KTRQO	4SNK	JMF]D
W~yrq|rmeaaM]Xa]	PLD	
Xac\KTRQO	QaHKYGPGF\4WXyrq|rmeaaM]XaIMI

\G\\a
cSNK	JMF]D
Wyrq|rmeaaM]Xa_K_QN_\W	a]a	cSNK	JMF]D
WXaQDFYTWX_RM[E4~yrq|rmeaaM]Xa_NQ
LUMaaOVac\KTRQO	4L[JKLP44C4WXQaHKYGPGF\ KIPWOKK	
UJI[KE4~yrq|rmeaaM]Xa_NQ
LUMaaOVac\KTRQO	4\KTRQO	~yrq|rmeaaM]XaPP_MVXQR[a	
cU[GI444WX\KTRQO	E4~yrq|rmeaaM]Xa]S[MMZT
ac\KTRQO	yrq|rmeaaM]XaUTQXHGKL\Ka
cK	G[KIa[HID_TQaHKYGPGF\b4O]JN\YHLYV~yrq|rmeaaM]Xa]	PLD	
Xac\KTRQO	KIPWOKK	
UJI[K4~yrq|rmeaaM]Xa_NQ
LUMaaOVac\KTRQO	44WXO]JN\YHLYVK	G[KIa[HID_TQWVIDDHOPHQ[VKZM_UMYGNJ\XYTW[WWPHJQ_4C4L[JKLP4C[RM[E444~yrq|rmeaaM]XaJZ_MYLKaLa	c\KTRQO	4~yrq|rmeaaM]Xa_NQ
LUMaaOVac\KTRQO	4444C4C4QaHKYGPGF\KIPWOKK	
UJI[K
	
4444\KTRQO	~yrq|rmeaaM]XaPP_MVXQR[a	
cU[G]QaHKYGPGF\4444WX\KTRQO	L[JKLP4~yrq|rmeaaM]Xa]S[MMZT
ac\KTRQO	yrq|rmeaaM]XaUTQXHGKL\Ka
cK	G[KIa[HID_TQaHKYGPGF\b4O]JN\YHLYV~yrq|rmeaaM]Xa]	PLD	
Xac\KTRQO	KIPWOKK	
UJI[K4WXO]JN\YHLYVK	G[KIa[HID_TQWVIDDHOPHQ[VKZMXYTW[WWPHJQ_IQ[
HR_4~yrq|rmeaaM]Xa_NQ
LUMaaOVac\KTRQO	4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPYaHGZ[[LY_
]KLL[PJLGLZ_UYa
4E4WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJBB]KLL[PJL[JKLPIQ[
HR_
LGLZ_UYa
bP4WXyrq|rmeaaM]Xa_[
SWPR]Nac_UMYGNJ\]KLL[PJXRIZO\]NZTWZVnl{yaqxxm{ja}njkl{E4[WJ
YR]IJVXXRIZO\]NZTWZVececyrq|rmeaaM]XaNJ]SSODDIGGaacXRIZO\]NZTWZVecec4J[_V\UWVUyrq|rmeaaM]Xa[NP\	U	ac]KLL[PJ[WJ
YR]IJVX4IVWR[yrq|rmeaaM]XaIMI

\G\\a
cJ[_V\UWVUyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_J[_V\UWVUaZSE444[WJ
YR]IJVXyrq|rmeaaM]XaNJ]SSODDIGGaacaZSec4J[_V\UWVUyrq|rmeaaM]Xa[NP\	U	ac]KLL[PJ[WJ
YR]IJVX
4C44L[JKLPyrq|rmeaaM]Xa[NP\	U	ac]KLL[PJ[WJ
YR]IJVXbPLGLZ_UYa
bPyrq|rmeaaM]Xa[NP\	U	ac]KLL[PJ[WJ
YR]IJVX4C444L[JKLPD	]I_DOGLGLZ_UYa
bP bP]KLL[PJ4C4XKP]JWQPOYRGP[M
J]UHJF]Ra
U[G4444E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	L[JKLPJLK[4[MZL
RLIF]WU~Y[JaQNJWQPIQ[
HR_U[G4WXyrq|rmeaaM]XaIMI

\G\\a
c[MZL
RLIF]WUyrq|rmeaaM]Xa_K_QN_\W	a]a	c[MZL
RLIF]WUBX_RM[E4F_aLRUKPPPL[yrq|rmeaaM]XaZLWL
M]XJPacB[MZL
RLIF]WU4WXWPJF_aLRUKPPPL[ecWPJyrq|rmeaaM]XaD]SGTYaFPQHDacF[FWPJF_aLRUKPPPL[ec `L[JKLPX_RM[4444C444L[JKLPJLK[444C4444XKP]JWQPHDZZFLJaIRTM\QSLDPNU[G4E44WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_L[JKLP444]YGV_]NUKNSWPJyrq|rmeaaM]XaD]SGTYaFPQHDac
4[MZL
RLIF]WU~Y[JaQNJWQPRYN[aTSQUDQ
U[G444PLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
c[MZL
RLIF]WUyrq|rmeaaM]Xa_K_QN_\W	a]a	c[MZL
RLIF]WUBX_RM[E4F_aLRUKPPPL[yrq|rmeaaM]XaZLWL
M]XJPacB[MZL
RLIF]WU4WXWPJF_aLRUKPPPL[ec]YGV_]NUKNSPLX
MHTUPWPJF_aLRUKPPPL[ec4C44PLX
MHTUP4~KNZ_J[aQNJWQPSF]
TFJDU[G]YGV_]NUKNSBPLX
MHTUPD	]I_DOG4WXPLX
MHTUP QWVIDDHOPHQ[VKZM_UMYGNJ\
IQ[
HR_U[G4C4XKP]JWQPTa	J\N
T_KWU	FDG4444E4JLGE4WXZ[XWP[ZXYTW[WWPHJQ_	L[JKLP4WXZ[XWP[ZD	]I_DOGBB~yrq|rmeaaM]XaURRZW
ITGa
cina}qpj{pjazwlBB[]SUDZNOTUPina}qpj{pjazwlL[JKLP444G
SM	KLTZOJP[Hina}qpj{pjazwl444JZNVTG
SM	KLTZOJP[HD	]I_DOG4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
	
4RNDT\KHO_LYFJN
WLK\P|mnjvD	]I_DOG
`IQ[
HR_4F
VNOXGDX\]MGUOK\T\L]4YKYRaNa

UYFJN
WLK\P|mnjvRYN[aTSQUDQ
		4RVMDSFYDyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	QWMZ
HN]OGMKVDOXa	X_RM[44NOSQVWTRPLRVMDSFYDX_RM[yrq|rmeaaM]XaUaHYNJDK\a	cRVMDSFYD4GZ]IWYINWMM[Jyrq|rmeD	]I_DOGc NL[XWFyrq|rmeD	]I_DOGc NL[XWFSF]
TFJD4V]RLTZYO_UMYGNJ\yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacaGPQ]VFQS_QMJLWPYTJ_	QLHU	YJSMDSOF
`
4JMM[VY	X_PVSJLM	JI
YGTaRGYG[X4IQ[
HR_
4_LL_Gaamrkyaaaadwnaps{aaaamvsqnau{gaaaaqnjaps{aaaainanl{xwfaaaayklzaps{aaaah{lmwqpaa4_LL_GaGPQ]VFQS_QRNDT\KHO_LNOSQVWTRPLYKYRaNa

UGZ]IWYINV]RLTZYORINYW\WDWV_QNR
I	44WXJMM[VY	X_PVSJE444WXWPJY[JaQNJWQPRYN[aTSQUDQ
	 QWVIDDHOPHQ[VKZMD	]I_DOG_UMYGNJ\4L[JKLP44C4]KLL[PJ~yrq|rmeaaM]XaVWRNOHYa]Oa	cJZNVT~yrq|rmeaaM]XaHSO\NMa_Da
cJZNVT4WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZMD	]I_DOG_UMYGNJ\4L[JKLP4444C4]KLL[PJT_DLVDPGFPFPaDQRK]KLL[PJ4DX_
ZZZ	OLRORINYW\WDWV_QNR
I	YFJN
WLK\P|mnjvIQ[
HR_`4G
GDOHVVHPLX_UMYGNJ\DX_
ZZZ	OLROSF]
TFJD
44GLaSFK[\]aDaSF]
TFJDDX_
ZZZ	OLRO_UMYGNJ\
4WVWIWYMZ
YFJN
WLK\P|mnjvD	]I_DOGFF44MJDMWF\_	YW]]yrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
WVWIWYMZ
_UMYGNJ\	]KLL[PJ4ITaMNOyrq|rmeaaM]Xa_K_QN_\W	a]a	cMJDMWF\_	YW]]_UMYGNJ\X_RM[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJG
GDOHVVHPLXX_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJGLaSFK[\]aDaX_RM[ITaMNOE4KW
FXVNDYXM]QQ4L[JKLP4C4]KLL[PJyrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
MJDMWF\_	YW]]444WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZMSF]
TFJDSF]
TFJD4L[JKLP4CE4]KLL[PJT_DLVDPGFPFPaDQRK]KLL[PJ444KRU
M	]_OKyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\
JMM[VY	X_PVSJ444VWTaD\PV]yrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJ4444WXVWTaD\PV]E4WXOYRGP[M
J]UHJF]Ra
_UMYGNJ\E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_SF]
TFJD4L[JKLP4C4WXGXLa_NLOL_PJZNVT]KLL[PJE4444QWVIDDHOPHQ[VKZMXYTW[WWPHJQ__UMYGNJ\4L[JKLP444C4HDZZFLJaIRTM\QSLDPNRYN[aTSQUDQ
4C[RM[E4WXGXLa_NLOL_PJZNVTE4QWVIDDHOPHQ[VKZMD	]I_DOGRYN[aTSQUDQ
4L[JKLP4C44C4KRVZ_GODDVYaHGZ[[LY_
]KLL[PJG
GDOHVVHPLXbPKRU
M	]_OKbPGLaSFK[\]aDa4WXTO[]UPZVQVUTYTJZNVTKRVZ_GODDVE44L[JKLP4C4WUUIP	M_XOZKJ	YHTJZNVT44Xa\
Qa\
N_TUJZNVT4KW
FXVNDYXM]QQ4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOGQ	MNQOPFD4444C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPYUVUXKT_aKFVQTS4E4JLGE4WXZ[XWP[ZIQ[
HR_	L[JKLP4WX\J

DH]GQG	FQIXTDWYLRT_NPTYMLPL[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	L[JKLP4WXyrq|rmeaaM]XaFOMVMVNG[KNacSF]
TFJDL[JKLP4WXWMM[Jam{lh{le_UMYGNJ\
cL[JKLP4WXY[JaJL_PMW[PJRYN[aTSQUDQ
L[JKLP4]L	L]ZNYDMGUOK\T\L]4WX~yrq|rmeaaM]XaS

	ZLD	a
c]L	L]ZNYDMO]\DJR_OJ
	ZVVP]L	L]ZNYD



JLK[4WX~yrq|rmeaaM]XaS

	ZLD	a
c]L	L]ZNYDBB~yrq|rmeaaM]XaURRZW
ITGa
c]L	L]ZNYDE4]L	L]ZNYD|mnjv_UMYGNJ\
4WX~yrq|rmeaaM]XaURRZW
ITGa
c]L	L]ZNYD]L	L]ZNYDKOPMXO	]LQ4C4ZMIFIJR_ZQIaYFJN
WLK\P|mnjvY	4QG]_TT\XIQ[
HR_ZMIFIJR_ZQIa_UMYGNJ\	
44XKRaOY
L]]L	L]ZNYDQG]_TT\X4OHaN
\N[][]L	L]ZNYDXYTW[WWPHJQ_ZMIFIJR_ZQIa4XQL[_]V_LL_G]L	L]ZNYD|mnjv_UMYGNJ\
KOPMXO	]LQ_M\[SNQONGSRIE4G[M_]NMX\\	Q\[SNQONGSRID	]I_DOGZMIFIJR_ZQIa4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacG[M_]NMX\\	QE44\PJK_I\DF	SRWPJ~yrq|rmeaaM]Xa_GRUDISIa	cG[M_]NMX\\	Q4444WX\PJK_I\DF	SRyrq|rmeaaM]XaD]SGTYaFPQHDacF	ZFZ	BB\PJK_I\DF	SR yrq|rmeaaM]XaD]SGTYaFPQHDac
		E4_I	Q]G
P
G[M_]NMX\\	Q4]QPJWPK[4C4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac\[SNQONGSRISF]
TFJD	ZMIFIJR_ZQIaRYN[aTSQUDQ
	
L[JKLP4_I	Q]G
P
G[M_]NMX\\	Q4C4C4KPM[J\[SNQONGSRIG[M_]NMX\\	Q\PJK_I\DF	SR44YTVJ]LJSYGY|mnjvXYTW[WWPHJQ_QG]_TT\X44WX]L	L]ZNYD|mnjvRYN[aTSQUDQ

~yrq|rmeaaM]XaJSJX
DZZNIIJacYTVJ]LJSYGYPWOFFGWURYH]M[YTVJ]LJSYGYX_RM[E4Y_HVRRKFFH]X
]VL
RYTVJ]LJSYGY	4WX_I	Q]G
P
YTVJ]LJSYGYyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~QN]_]V[aWPH_RWZ_J[YTVJ]LJSYGYJLK[4C4444KPM[JYTVJ]LJSYGY44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacOHaN
\N[][WPJ~yrq|rmeaaM]Xa_GRUDISIa	cOHaN
\N[][ yrq|rmeaaM]XaD]SGTYaFPQHDacL[JKLP4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXKRaOY
L]yrq|rmeaaM]XaD]SGTYaFPQHDacWPJ~XWR[]JWS[XKRaOY
L]
L[JKLP4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXKRaOY
L]E4IMUY	T[YQ~yrq|rmeaaM]XaJSJX
DZZNIIJac]L	L]ZNYDXYTW[WWPHJQ_ZMIFIJR_ZQIayrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c]L	L]ZNYDIQ[
HR_ZMIFIJR_ZQIa4WXIMUY	T[YQyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_IMUY	T[YQH[LMWQPa]QSN_L[IMUY	T[YQRINYW\WDWV_QNR
I	 L[JKLP4KPM[JIMUY	T[YQ4C4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXKRaOY
L]E4]DHZ[LYXI]L	L]ZNYDD	]I_DOGYFJN
WLK\P|mnjvYFF44PUJUGWO	FF~yrq|rmeaaM]XaJSJX
DZZNIIJac]DHZ[LYXIMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
c]DHZ[LYXI4I]WaQ\P\NU4WXPUJUGWO	FFE4ROUH	K\HQJyrq|rmeaaM]XaZLWL
M]XJPacBPUJUGWO	FF4444I]WaQ\P\NUWPJROUH	K\HQJec4C4444WXI]WaQ\P\NU yrq|rmeaaM]XaD]SGTYaFPQHDacI]WaQ\P\NU QWVIDDHOPHQ[VKZMIQ[
HR_SF]
TFJD4[RM[WXI]WaQ\P\NUyrq|rmeaaM]XaD]SGTYaFPQHDacWPJ~XWR[]JWS[XKRaOY
L] QWVIDDHOPHQ[VKZMD	]I_DOGIQ[
HR_4KPM[J]DHZ[LYXIPUJUGWO	FFROUH	K\HQJI]WaQ\P\NU4C4XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW

L[JKLP4ZNQD
JPDYO]_TSGKYNR	aUMM4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP_UMYGNJ\	
4_FF[WYX\OGKOPMXO	]LQSF]
TFJD
4FN\OOGNYJJTFOWX~yrq|rmeaaM]XaURRZW
ITGa
c_FF[WYX\OG4_FF[WYX\OGaGPQ]VFQS_QD	]I_DOG	
4KOPMXO	]LQD	]I_DOGaGPQ]VFQS_QaGPQ]VFQS_QXYTW[WWPHJQ_44HMYSQayrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	yrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklravqmjWMM[Jam{lh{leSF]
TFJDcam{lh{le_UMYGNJ\c4IDWUKL
DZ[XWP[ZRYN[aTSQUDQ
inskanrkywpazwlinskanrkywpazwlKOPMXO	]LQXYTW[WWPHJQ_
4JaF_V_RD[[FYNZ[XWP[ZRYN[aTSQUDQ
inanrkywpazwlinanrkywpazwlKOPMXO	]LQD	]I_DOG		4ZaXVD\SJM
VZ[XWP[ZD	]I_DOGina}qpj{pjazwlKOPMXO	]LQ4]GUaXQT
J[D[LM	JI
YGTaRGYG[X4RYN[aTSQUDQ
44_LL_Gaanjva|
aaaanrkywpa|m{
aaaazqswpaaaav|a|
aaaaynjva|
aaaa|mnjva|
aaaa}qpj{pjzwla|
aaaaskzwla|
aaaanrkywpzwla|
aaaamrkyaaaah{lmwqpaa444_LL_Gyrq|rmeaaM]Xa\	V]W	QFacFN\OOGNYJJTFOWXZNQD
JPDYOHMYSQayrq|rmeaaM]Xa\	V]W	QFacOHaN
\N[][yrq|rmeaaM]Xa\	V]W	QFacXKRaOY
L]yrq|rmeaaM]Xa\	V]W	QFac|mnjvyrq|rmeaaM]Xa\	V]W	QFacZaXVD\SJM
Vyrq|rmeaaM]Xa\	V]W	QFacIDWUKL
Dyrq|rmeaaM]Xa\	V]W	QFacJaF_V_RD[[FYNyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPD	]I_DOGRINYW\WDWV_QNR
I	44WX]GUaXQT
J[D[E4WXWPJY[JaQNJWQPXYTW[WWPHJQ_	 QWVIDDHOPHQ[VKZMD	]I_DOGD	]I_DOG4L[JKLP4C4WXGQS[a	
DD\SGLHV]GUaXQT
J[D[E4QWVIDDHOPHQ[VKZM_UMYGNJ\_UMYGNJ\
4L[JKLP4C4WXTO[]UPZVQVUTYTXKRaOY
L]]GUaXQT
J[D[E4GTOMLTaWMG
IQPG
XKRaOY
L]ZQYIVUTIDP[XTYXJ4Y_HVRRKFFH]X
]VL
RXKRaOY
L]	4Xa\
Qa\
N_TUXKRaOY
L]4U
]TV\
IZDSU]L	L]ZNYD_UMYGNJ\ZMIFIJR_ZQIayrq|rmeaaM]XaaQKLGJP]_OIac]GUaXQT
J[D[RYN[aTSQUDQ
4U
]TV\
IZDSU]L	L]ZNYDXYTW[WWPHJQ_ZMIFIJR_ZQIaRINYW\WDWV_QNR
I	SF]
TFJD4~WP]RKZ[aQP][XKRaOY
L]4M[JaJL_PMW[PJD	]I_DOG
4C4KPM[JIDWUKL
DJaF_V_RD[[FYNZaXVD\SJM
V444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD	Q	MNQOPFD4444C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPRKHMW]\JKFVXXU[INGT
J]4E4WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]L[JKLPX_RM[44FUI		]\yrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]4WXFUI		]\ 

L[JKLPJLK[4444WXFUI		]\

L[JKLPX_RM[4[P[QN[T[GMQONyrq|rmeaaM]Xa[NP\	U	acXXU[INGT
J]
4IZ_VXMHVTIaZyrq|rmeaaM]XaVWWSWO[Z\ac[P[QN[T[GMQONyrq|rmeaaM]XaVWWSWO[Z\ac[P[QN[T[GMQONbJ4L[JKLPIZ_VXMHVTIaZyrq|rmeaaM]XaNJ]SSODDIGGaac[P[QN[T[GMQON 4C4XKP]JWQPPJYY\WJKRYWPPSOU]WZRDX_RM[4E4444MJ_JW]XaQDFYTWPKRR4WXOU]WZRDE4XaQDFYTWPKRR444C4WXXaQDFYTWPKRRL[JKLPXaQDFYTW4XXU[INGT
J]YLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]yrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J] 
	yrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]

RKHMW]\JKFVXXU[INGT
J]GQS[a	
DD\SGLHVXXU[INGT
J]E44XaQDFYTWXXU[INGT
J]4L[JKLPXaQDFYTW4C4UaJ_FM_LGUOJ[XOIWQXYTW[WWPHJQ_4WXyrq|rmeaaM]XaIMI

\G\\a
cUaJ_FM_Lyrq|rmeaaM]XaNJ]SSODDIGGaacUaJ_FM_L 
yrq|rmeaaM]XaNJ]SSODDIGGaacUaJ_FM_L


RKHMW]\JKFVUaJ_FM_LGQS[a	
DD\SGLHVUaJ_FM_LE4XaQDFYTWUaJ_FM_L4L[JKLPXaQDFYTW4C4XaQDFYTWX_RM[4L[JKLPXaQDFYTW4C4444XKP]JWQP]_TSGKYNR	aUMMOU]WZRDX_RM[4444E4444MJ_JW]HPTMOHYaaVNTPKRR44WXOU]WZRDE4HPTMOHYaaVNTPKRR4C4WXHPTMOHYaaVNTPKRRL[JKLPHPTMOHYaaVNT4XXU[INGT
J]PJYY\WJKRYWPPS4WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]BByrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J]
	BByrq|rmeaaM]XaNJ]SSODDIGGaacXXU[INGT
J] 
BBRKHMW]\JKFVXXU[INGT
J]BBGQS[a	
DD\SGLHVXXU[INGT
J]E4HPTMOHYaaVNTX_RM[4L[JKLPHPTMOHYaaVNT4C4444HPTMOHYaaVNTyrq|rmeaaM]Xa\	V]W	QFacLQMN_N_SKUQUTa[KXXU[INGT
J]4L[JKLPHPTMOHYaaVNT4444C4XKP]JWQPYWTIF]KD_PTLRJLFQGaU[T4E4WXyrq|rmeaaM]XaIMI

\G\\a
cTLRJLFQGaU[TBByrq|rmeaaM]XaNJ]SSODDIGGaacTLRJLFQGaU[T`
BByrq|rmeaaM]Xa[NP\	U	acTLRJLFQGaU[TbFXbF\L[JKLP444IKOFUW	XSOL~yrq|rmeaaM]XaQXZTaR[L
VQOa		chyrq|rmeaaM]Xa[NP\	U	acTLRJLFQGaU[TFF4IKOFUW	XSOLyrq|rmeaaM]Xa]HYHVUa
cIKOFUW	XSOLIKOFUW	XSOLec4WXIKOFUW	XSOL
BBIKOFUW	XSOL 

	L[JKLPIKOFUW	XSOL44L[JKLP4C4XKP]JWQPHVHQUNUaXMU\YLFW	W]IFHJ	W_M4E4L[JKLPyrq|rmeaaM]XaS]ZINNJ_acV[FZ[]]IFHJ	W_Mec444C4XKP]JWQPG\VSaUWFRZGDODNOF_PN[NTPVH4E4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBBDODNOF_PN[NTPVHL[JKLPDODNOF_PN[NTPVH4MJ_JW]FIIUZ	PKRR4WXFIIUZ	PKRRE444FIIUZ	X_RM[44WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
E4aZZZ[XWP[ZSF]
TFJDina}qpj{pjazwlZ[XWP[ZSF]
TFJD
|mnjv4WXaZZE4SMXJGSM]II~ZWMUaXL[[aMN_][aZZ4WXSMXJGSM]IIX_RM[SMXJGSM]II 	FIIUZ	JLK[44C4C4WXFIIUZ	E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
~KNZ_J[aQNJWQPIQ[
HR_
yrq|rmeaaM]XaD]SGTYaFPQHDacSF]
TFJD444C[RM[WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ


E4FQZaQ[YYMFWPJY[JaQNJWQPRYN[aTSQUDQ

44WXFQZaQ[YYMFyrq|rmeaaM]XaD]SGTYaFPQHDacFQZaQ[YYMFFIIUZ	X_RM[4444C4C4WXFIIUZ	E444L[JKLPDODNOF_PN[NTPVH4C4]ZOTTFT\QTKK[JO	JU_WaWWOJZK[	S4WX]ZOTTFT\QTKKBB]ZOTTFT\QTKK FX\\\F
ZX
E444QIQKFOXaH	
yrq|rmeaaM]XaFL_RINU
a
c	4C[RM[WX]ZOTTFT\QTKK 	E4QIQKFOXaH	

yrq|rmeaaM]XaFL_RINU
a
c
4C[RM[E4L[JKLPDODNOF_PN[NTPVH44C44WXyrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVH QIQKFOXaHL[JKLPDODNOF_PN[NTPVH4WXyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaNGLV\SLPGacDODNOF_PN[NTPVHXYTW[WWPHJQ_
L[JKLPDODNOF_PN[NTPVH4IVWR[yrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVHQIQKFOXaH
	
E4WGIQa[KKMI4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
E4JLGE4WGIQa[KKMI~yrq|rmeaaM]XaG_YaDRUXUNa
	cL_PZQSa\GJ[M444C]_J]VjVLQI_\R[Q	MNQOPFDE4WGIQa[KKMI4C]_J]V{F][NJWQPQ	MNQOPFDE4WGIQa[KKMI4C4C444WXyrq|rmeaaM]XaNJ]SSODDIGGaacWGIQa[KKMI
	E4WGIQa[KKMIyrq|rmeaaM]XaaQKLGJP]_OIacKPWOWZJLK[4444IVWR[yrq|rmeaaM]XaNJ]SSODDIGGaacWGIQa[KKMI	WGIQa[KKMIyrq|rmeaaM]XaaQKLGJP]_OIacWGIQa[KKMI4C4DODNOF_PN[NTPVHbPWGIQa[KKMISF]
TFJD
4C44L[JKLPDODNOF_PN[NTPVH4C44XKP]JWQPT_DLVDPGFPFPaDQRKDODNOF_PN[NTPVH4E4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBByrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVH
	L[JKLPDODNOF_PN[NTPVH4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_
DODNOF_PN[NTPVH4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPPLX
MHTUPDODNOF_PN[NTPVH4444C4XKP]JWQP[JO	JU_WaWWOJZK[	S4E4MJ_JW]]UTZK]OUFLPKRR4444WX]UTZK]OUFLPKRRL[JKLP]UTZK]OUFL4]UTZK]OUFL44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDL[JKLP]UTZK]OUFL4TLRJLFQGaU[T~yrq|rmeaaM]Xa[PD\GWFacRYN[aTSQUDQ
4WXyrq|rmeaaM]XaIMI

\G\\a
cTLRJLFQGaU[TL[JKLP]UTZK]OUFL4TLRJLFQGaU[Tyrq|rmeaaM]XaVMQGFWM]acTLRJLFQGaU[T4WXTLRJLFQGaU[TL[JKLP]UTZK]OUFL4WXTLRJLFQGaU[TIQ[
HR_E4]UTZK]OUFL4L[JKLP]UTZK]OUFL44C4[MZL
RLIF]WUXRQ_JTLRJLFQGaU[T4444WXKROP	L\yrq|rmeaaM]XaOLaK	NN	acyrq|rmeaaM]Xa[NP\	U	acTLRJLFQGaU[T4WXWXKROP	L\y[MZL
RLIF]WU	

	

	44[RM[WXWXKROP	L\s[MZL
RLIF]WU
4[RM[WXWXKROP	L\u[MZL
RLIF]WU4WX[MZL
RLIF]WU ]UTZK]OUFLWPJ[MZL
RLIF]WU4L[JKLP]UTZK]OUFL4C4444XKP]JWQPTXYNX
	DGPWJNQaHKYGPGF\4E4QaHKYGPGF\WPJQaHKYGPGF\4WXQaHKYGPGF\L[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	L[JKLPX_RM[4TM]L[	YVF[JO	JU_WaWWOJZK[	S4WXTM]L[	YVFL[JKLPJLK[4WXTM]L[	YVFL[JKLPX_RM[4\XYLZGF[JFSR~S[SQLGaY[JaKM_Y[JLK[444WXyrq|rmeaaM]XaNIR	Ta	ac\XYLZGF[JFSRBB\XYLZGF[JFSRL[JKLPX_RM[4L[JKLPTM]L[	YVF\XYLZGF[JFSR QaHKYGPGF\F_		FZ	4C444XKP]JWQPGXG
[XY	_aR
D
GQaHKYGPGF\4E4QaHKYGPGF\WPJQaHKYGPGF\4WXQaHKYGPGF\L[JKLPX_RM[4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	L[JKLPJLK[4TM]L[	YVF[JO	JU_WaWWOJZK[	S4WXTM]L[	YVFL[JKLPJLK[4WXTM]L[	YVFL[JKLPJLK[44\XYLZGF[JFSR~S[SQLGaY[JaKM_Y[JLK[4WXyrq|rmeaaM]XaNIR	Ta	ac\XYLZGF[JFSRBB\XYLZGF[JFSRL[JKLPJLK[4L[JKLPTM]L[	YVF\XYLZGF[JFSR QaHKYGPGF\`
	4C4XKP]JWQPYLLGXD	WRM]	[DNIZPaYMYD_D4444E4WXyrq|rmeaaM]XaIMI

\G\\a
cNIZPaYMYD_DBBNIZPaYMYD_DBB~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DL[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~]R[_LMJ_J]_]V[JLK[NIZPaYMYD_D4QaHKYGPGF\~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_D4WXyrq|rmeaaM]XaNIR	Ta	acQaHKYGPGF\BBQaHKYGPGF\L[JKLPX_RM[4WXQaHKYGPGF\ 		
	L[JKLPPKRR4WXQaHKYGPGF\ 


TXYNX
	DGPWJNQaHKYGPGF\L[JKLPPKRR44DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRRQaHKYGPGF\444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBByrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVHQaHKYGPGF\L[JKLPX_RM[4L[JKLPQaHKYGPGF\ FX]F]ZT_DLVDPGFPFPaDQRKDODNOF_PN[NTPVHDODNOF_PN[NTPVH4C4XKP]JWQPXa\
Qa\
N_TUNIZPaYMYD_D44E4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG

BByrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
L[JKLP4444WXyrq|rmeaaM]XaIMI

\G\\a
cNIZPaYMYD_DBBNIZPaYMYD_DBB~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DL[JKLP4WXWMM[Jyrq|rme_UMYGNJ\cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeXYTW[WWPHJQ_
cE4yrq|rmeRYN[aTSQUDQ

cY[JaQNJWQPD	]I_DOG_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cyrq|rmeXYTW[WWPHJQ_cyrq|rmeRYN[aTSQUDQ
c_LL_G4C4]IFHJ	W_Myrq|rmeIQ[
HR_	c4DODNOF_PN[NTPVHYLLGXD	WRM]	[DNIZPaYMYD_D444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHL[JKLP4]IFHJ	W_Meyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_Dc_LL_GN NIZPaYMYD_DV yrq|rmeaaM]XaaQKLGJP]_OIacDODNOF_PN[NTPVHY RINYW\WDWV_QNR
I	J yrq|rmeaaM]XaD]SGTYaFPQHDac4WXyrq|rmeaaM]XaOG\FSVKac]IFHJ	W_M E4XQL[_]V]IFHJ	W_M_MI	ZLWVK_I [MZL
RLIF]WUE4WXyrq|rmeaaM]Xa]HYHVUa
c[MZL
RLIF]WUBBWMM[J[MZL
RLIF]WUeJcBBWPJ[MZL
RLIF]WUeJcyrq|rmeaaM]XaD]SGTYaFPQHDac
KPM[J]IFHJ	W_MeI	ZLWVK_Ic4C44IVWR[yrq|rmeaaM]XaOG\FSVKac]IFHJ	W_M 	
E444HYNMHYUSKNGPKRR4ROPPaOGXF	HPKRR444XQL[_]V]IFHJ	W_M_MI	ZLWVK_I [MZL
RLIF]WUE4QRZaLP\yrq|rmeaaM]Xa]HYHVUa
c[MZL
RLIF]WUWMM[J[MZL
RLIF]WUeJcWPJ[MZL
RLIF]WUeJc4WXROPPaOGXF	HPKRRBBQRZaLP\ROPPaOGXF	HE444ROPPaOGXF	HQRZaLP\4HYNMHYUSKNGI	ZLWVK_I44C4C4WXHYNMHYUSKNGPKRR\L[_U4KPM[J]IFHJ	W_MeHYNMHYUSKNGc4C4C4KNZ_J[aQNJWQPRYN[aTSQUDQ
]IFHJ	W_MSF]
TFJD4yrq|rmeRYN[aTSQUDQ
c]IFHJ	W_M444C4XKP]JWQPPWOFFGWURYH]M[NIZPaYMYD_D44E44WXyrq|rmeaaM]XaIMI

\G\\a
cNIZPaYMYD_DBBNIZPaYMYD_DL[JKLPX_RM[4WXWMM[Jyrq|rmeIQ[
HR_cBByrq|rmeaaM]Xa]HYHVUa
cyrq|rmeIQ[
HR_cE4yrq|rmeXYTW[WWPHJQ_cyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG

Y[JaQNJWQPXYTW[WWPHJQ__LL_G_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cyrq|rmeSF]
TFJDcyrq|rmeIQ[
HR_c_LL_G4C4]IFHJ	W_Myrq|rmeD	]I_DOGc4444]N]L	LM	Myrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_D4444WXWMM[J]IFHJ	W_Me]N]L	LM	Mcyrq|rmeaaM]Xa]HYHVUa
c]IFHJ	W_Me]N]L	LM	McWMM[J]IFHJ	W_Me]N]L	LM	MceVcE444WXWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_D F	[ZF\L[JKLPD	]I_DOG4DODNOF_PN[NTPVHYLLGXD	WRM]	[DNIZPaYMYD_D44WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHE4L[JKLPyrq|rmeaaM]XaaQKLGJP]_OIacDODNOF_PN[NTPVH]IFHJ	W_Me]N]L	LM	MceVcJLK[XYTW[WWPHJQ_4C4L[JKLPX_RM[4C4WXaKIGURZU\I_P
SaFNIZPaYMYD_D
E4SGDQ_VIHJ
XIMR~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRR
		4WXyrq|rmeaaM]XaIMI

\G\\a
cSGDQ_VIHJ
XIMRyrq|rmeaaM]Xa_K_QN_\W	a]a	cSGDQ_VIHJ
XIMR_UMYGNJ\
X_RM[L[JKLPIQ[
HR_
4C4L[JKLPX_RM[4C44XKP]JWQPTUPNDHRS\4E4MJ_JW]]IFHJ	W_MPKRR4WX]IFHJ	W_MPKRRL[JKLP]IFHJ	W_M4DODNOF_PN[NTPVHYLLGXD	WRM]	[DXTDWYLRT_NPTYMLP4]IFHJ	W_Myrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHDODNOF_PN[NTPVHyrq|rmeaaM]XaaQKLGJP]_OIacDODNOF_PN[NTPVH4L[JKLP]IFHJ	W_M4C4XKP]JWQPI[Ua		GLPGTSTWDFSH4E444L[JKLPyrq|rmeaaM]Xa[NP\	U	acTUPNDHRS\4C4XKP]JWQPOJD]N[U[WTRPRWI4E4L[JKLPMGUOK\T\L]_UMYGNJ\YFJN
WLK\P|mnjvD	]I_DOG

SF]
TFJD4C4XKP]JWQPYYFLN]J\S]QRWHRR4444E4DLKYGSSTF_Q_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG

E4Q[XXS
U~Y[JaQNJWQPRYN[aTSQUDQ
	_LL_G444WXyrq|rmeaaM]Xa]HYHVUa
cQ[XXS
UDLKYGSSTF_QQ[XXS
U4C4DODNOF_PN[NTPVH~yrq|rmeaaM]XaJSJX
DZZNIIJacOJD]N[U[WTRPRWI~yrq|rmeaaM]XaHSO\NMa_Da
cOJD]N[U[WTRPRWI444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVH_UMYGNJ\	E4P_FD
PW
QJOyrq|rmeaaM]Xa]FQGV	\Sacyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVH
JLK[4WXyrq|rmeaaM]Xa]HYHVUa
cP_FD
PW
QJO[SNJGDLKYGSSTF_Qe_UMYGNJ\cBB[SNJGP_FD
PW
QJOeXYTW[WWPHJQ_cP_FD
PW
QJOeSF]
TFJDc DLKYGSSTF_QeSF]
TFJDcDLKYGSSTF_QP_FD
PW
QJO4C444L[JKLPDLKYGSSTF_Q4C4444XKP]JWQPPTaaNIZYOT
I_aJIVPTHW[H4E444JLGE4WXZ[XWP[ZSF]
TFJD
L[JKLP4QZ	HIYJR	HX[Xyrq|rmeaaM]XaD]SGTYaFPQHDac4WXJIVPTHW[HIQ[
HR_BBJIVPTHW[HRYN[aTSQUDQ
	E444NL[HYYFLN]J\S]QRWHRR444WX4WMM[JNL[HeSF]
TFJD	cNL[HeIQ[
HR_	cNL[HeSF]
TFJD	cJIVPTHW[H444QZ	HIYJR	HX[XWPJNL[HeIQ[
HR_	cJIVPTHW[HRYN[aTSQUDQ
		
FF4L[JKLP4C4DLKYGSSTF_Q_LL_G4H RINYW\WDWV_QNR
I	4XYTW[WWPHJQ_	 I[Ua		GLPGTSTWDFSH4RYN[aTSQUDQ
 XTDWYLRT_NPTYMLP4XYTW[WWPHJQ_ yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJD4444_UMYGNJ\	
 JIVPTHW[H4444XYTW[WWPHJQ_	 QZ	HIYJR	HX[X4SF]
TFJD	 QZ	HIYJR	HX[X4444D	]I_DOG WMM[Jam{lh{le_UMYGNJ\	cWPJam{lh{leRYN[aTSQUDQ
	cQZ	HIYJR	HX[X44WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4]MUX[WSY]_~KNZ_J[aQNJWQPIQ[
HR_	DLKYGSSTF_QSF]
TFJD		444WX]MUX[WSY]_X_RM[yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

E4aKaPRKX~Y[JaQNJWQPXYTW[WWPHJQ_	_LL_G4ZU_	SSM[ZRTTyrq|rmeaaM]Xa]HYHVUa
caKaPRKXBBWMM[JaKaPRKXe_UMYGNJ\	caKaPRKXeSF]
TFJD	cBBaKaPRKXeD	]I_DOG	cJIVPTHW[HBBWPJaKaPRKXeD	]I_DOGcQZ	HIYJR	HX[X4WXZU_	SSM[ZRTTWMM[Jyrq|rmeD	]I_DOGcyrq|rmeaaM]XaJFVY[	SJPKa	cyrq|rmeSF]
TFJDcyrq|rmeaaM]Xa__VX_]O[acyrq|rme_UMYGNJ\c_UMYGNJ\E4~yrq|rmeSF]
TFJDc ]V[]Ua]QPP[]JWQPX_RM[4~KNZ_J[aQNJWQP_UMYGNJ\	DLKYGSSTF_QD	]I_DOG4C4KPM[JaKaPRKXZU_	SSM[ZRTT444C4KPM[J]MUX[WSY]_4C4ZFNXLaR
WNWJSWMGUOK\T\L]44WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWBBMO]\DJR_OJ
	ZVVPZFNXLaR
WNWJSW
JLK[E4~yrq|rmeaaM]XaUM_SDP\\\a
cOJD]N[U[WTRPRWISF]
TFJD	yrq|rmeaaM]XaZNPRLPO\YVYacDLKYGSSTF_Q4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPTKH_JGFTZLTG]DLKYGSSTF_Q4E4WXyrq|rmeaaM]Xa]HYHVUa
cDLKYGSSTF_QBB[SNJGDLKYGSSTF_QeRYN[aTSQUDQ
cBByrq|rmeaaM]XaIMI

\G\\a
cDLKYGSSTF_QeXYTW[WWPHJQ_cL[JKLPIQ[
HR_4F_aLRUKPPPL[DLKYGSSTF_Qe_UMYGNJ\
c4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[BBWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acF_aLRUKPPPL[F
\F_L[JKLPIQ[
HR_4WXPa
X\SYQJTY	
][YKF_aLRUKPPPL[L[JKLPIQ[
HR_4K[\IIOSJWMM[JDLKYGSSTF_QeRYN[aTSQUDQ
cDLKYGSSTF_QeXYTW[WWPHJQ_c4DaH_O_	ZJFLWMM[JDLKYGSSTF_QeIQ[
HR_cWPJDLKYGSSTF_QeRYN[aTSQUDQ
c4WXK[\IIOSJXYTW[WWPHJQ_	L[JKLPDaH_O_	ZJFL yrq|rmeaaM]XaD]SGTYaFPQHDacDaH_O_	ZJFLD	]I_DOG	SF]
TFJD	4444WXK[\IIOSJSF]
TFJDL[JKLPRYN[aTSQUDQ
4444WXK[\IIOSJD	]I_DOGL[JKLPDaH_O_	ZJFL yrq|rmeaaM]XaD]SGTYaFPQHDacDaH_O_	ZJFLFF_UMYGNJ\	_UMYGNJ\4L[JKLPD	]I_DOG444C4XKP]JWQPJXQZWQYO][P\VZNIZPaYMYD_D4E4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_DL[JKLPX_RM[4ZMKUD
WPJ~yrq|rmeaaM]XaNDD_U_S]R\\acNIZPaYMYD_D44WXZMKUD


BBZMKUD
 


L[JKLPX_RM[4SGDQ_VIHJ
XIMR~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRR		4WXyrq|rmeaaM]XaIMI

\G\\a
cSGDQ_VIHJ
XIMRBByrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_	SGDQ_VIHJ
XIMRL[JKLPX_RM[444WXZMKUD
 FZ\X[\F
E4QIQKFOXaH~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_DX_RM[PKRRZMKUD
	4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cQIQKFOXaHyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_QIQKFOXaH4C4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHL[JKLPX_RM[4L[JKLPGQS[a	
DD\SGLHVDODNOF_PN[NTPVH4C4XKP]JWQPM]VKWGRWZRNYD
O
XHPRMU[FaK]JNV_HK4E4J]NMKZP~yrq|rmeaaM]XaHSO\NMa_Da
cD
O
XHPX_RM[PKRRF[F]4LRGJPa	W[DNLX~yrq|rmeaaM]XaHSO\NMa_Da
cRMU[FaK]JNV_HKX_RM[PKRRF_F\4WXyrq|rmeaaM]XaIMI

\G\\a
cJ]NMKZPBByrq|rmeaaM]XaIMI

\G\\a
cLRGJPa	W[DNLXL[JKLPX_RM[4IPaPZD__YaY_LX\FFaYT]PKRR44WXyrq|rmeaaM]Xa_[
SWPR]NacXKP]JWQPa[FWMJMbed_DacbJ]NMKZP[HYVXVW]_IPaPZD__YaY_[HYVXVW]_ec44WXyrq|rmeaaM]Xa_[
SWPR]NacXKP]JWQPa[FWMJMbed_DacbLRGJPa	W[DNLX[HYVXVW]_LX\FFaYT][HYVXVW]_ec4444L[JKLPIPaPZD__YaY_PKRRIPaPZD__YaY_LX\FFaYT]4C4XKP]JWQPPa
X\SYQJTY	
][YKNIZPaYMYD_D4E4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacNIZPaYMYD_D_UMYGNJ\4XQL[_]V_LL_Gyrq|rmeaaM]Xa]FMXaRDGSQacNIZPaYMYD_D\PQQYLWZWNM]_KP_MKSZ
H	MT
HE4JSX]LM[U[XTTW
KSZ
H	MT
H_UMYGNJ\aGPQ]VFQS_Q4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJSX]LM[U[XTTW
BBWPJ~yrq|rmeaaM]Xa_GRUDISIa	cJSX]LM[U[XTTW
yrq|rmeaaM]XaD]SGTYaFPQHDac
	
]QPJWPK[44UDGHT\Y]yrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cJSX]LM[U[XTTW
4WXUDGHT\Y]]QPJWPK[4DODNOF_PN[NTPVHYLLGXD	WRM]	[DNIZPaYMYD_D4WXDODNOF_PN[NTPVHPKRR]QPJWPK[4444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHDODNOF_PN[NTPVHyrq|rmeaaM]XaaQKLGJP]_OIacDODNOF_PN[NTPVHUDGHT\Y]L[JKLPJLK[4C4444L[JKLPX_RM[4C4XKP]JWQP_MZHILSNMSLG
QNIZPaYMYD_D4E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
BByrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
L[JKLP4]UTZK]OUFL~Y[JaQNJWQPD	]I_DOG_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
c]UTZK]OUFL]UTZK]OUFL_LL_G444]UTZK]OUFLeyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_DcNIZPaYMYD_D4444WXyrq|rmeaaM]XaOG\FSVKac]UTZK]OUFL 
]UTZK]OUFLyrq|rmeaaM]XaRSVOIDaFHTJac]UTZK]OUFL`PKRRJLK[4~KNZ_J[aQNJWQPRYN[aTSQUDQ
]UTZK]OUFLRYN[aTSQUDQ
4C4XKP]JWQPaa\ZZXOWWK[4E444WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
BByrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\L[JKLP444]UTZK]OUFL~Y[JaQNJWQP_UMYGNJ\_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
c]UTZK]OUFLBB[SNJG]UTZK]OUFLL[JKLP4G_OMYJKa_LL_G4XQL[_]V]UTZK]OUFL_MI	ZLWVK_I F_aLRUKPPPL[E4WXyrq|rmeaaM]XaIMI

\G\\a
cF_aLRUKPPPL[BBF_aLRUKPPPL[BB~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[]QPJWPK[4WXF_aLRUKPPPL[XTDWYLRT_NPTYMLP]QPJWPK[4XDaX\LUOO[FZYa~yrq|rmeaaM]XaI	WS[XMPacF_aLRUKPPPL[4YUH
T\	G	~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cXDaX\LUOO[FZYayrq|rmeaaM]XaIMI

\G\\a
cYUH
T\	G	XDaX\LUOO[FZYaYUH
T\	G	]QPJWPK[4KPM[JXDaX\LUOO[FZYaYUH
T\	G	4WXPWOFFGWURYH]M[F_aLRUKPPPL[X_RM[E4G_OMYJKaeI	ZLWVK_IcF_aLRUKPPPL[4]QPJWPK[4C4Y_HVRRKFFH]X
]VL
RF_aLRUKPPPL[
	4WX_I	Q]G
P
F_aLRUKPPPL[E4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~QN]_]V[aWPH_RWZ_J[F_aLRUKPPPL[JLK[4C[RM[WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[E44G_OMYJKaeI	ZLWVK_IcF_aLRUKPPPL[4C4C4~KNZ_J[aQNJWQPD	]I_DOGG_OMYJKaSF]
TFJD	4444C4XKP]JWQPVTFRPDJJWPaQIJ_	4E4JLGE4444Q	MNQOPFDyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~[LLQLaY[JaR_MJPKRR4WX4444yrq|rmeaaM]Xa]HYHVUa
cQ	MNQOPFD[SNJGQ	MNQOPFDeRYN[aTSQUDQ
c[SNJGQ	MNQOPFDeRYN[aTSQUDQ
c4yrq|rmeaaM]Xa_LHMQPFPD
Ma
cQ	MNQOPFDeRYN[aTSQUDQ

c_LL_G{a{llql{anlm{{a}ql{a{llql{a}qsnwr{a{llql{akm{la{llqlJLK[44E4YaS\KDM~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4a[X~yrq|rmeaaM]XaI	WS[XMPacQ	MNQOPFDeSF]
TFJDc444WXyrq|rmeaaM]XaIMI

\G\\a
cYaS\KDMyrq|rmeaaM]XaIMI

\G\\a
ca[Xa[XYaS\KDML[JKLP4444C4PTaaNIZYOT
I_aD	]I_DOG	4WXZ[XWP[ZSF]
TFJD
E4_HM]VRVP_
YK[UTJVF[HGFKQRY4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac_HM]VRVP_
YecE4[YPSNRZHRSW~yrq|rmeaaM]XaHSO\NMa_Da
c_HM]VRVP_
YecX_RM[PKRRFF	4WXyrq|rmeaaM]XaIMI

\G\\a
c[YPSNRZHRSWyrq|rmeaaM]Xa_K_QN_\W	a]a	c[YPSNRZHRSWRYN[aTSQUDQ
	RINYW\WDWV_QNR
I	E4MZ
[DPaGF~yrq|rmeaaM]XaJSJX
DZZNIIJac_HM]VRVP_
YecIQ[
HR_
~yrq|rmeaaM]XaHSO\NMa_Da
c_HM]VRVP_
Yec_UMYGNJ\
X_RM[PKRR444WXMZ
[DPaGF[YPSNRZHRSW~yrq|rmeaaM]XaSF
YSF[LIJ
Ta	c_HM]VRVP_
Yec_HM]VRVP_
Yec_UMYGNJ\
4C4C4KPM[J_HM]VRVP_
Y[YPSNRZHRSWMZ
[DPaGF4C4C]_J]VjVLQI_\R[[]\]M_	WU\UZHE4C]_J]V{F][NJWQP[]\]M_	WU\UZHE4444C44C4XKP]JWQPR]MDVH	TQGVJKMRMU[FaK]JNV_HK4444E4444WXyrq|rmeaaM]XaIMI

\G\\a
cRMU[FaK]JNV_HKL[JKLP4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cXYTW[WWPHJQ_
RMU[FaK]JNV_HKLDTDJN[DG\	FTE4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4444WXYWTIF]KD_Pyrq|rmeaaM]Xa]HN[Q	\\KPOVacPZSGFJRM[OJLK[L[JKLP4C4C4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cD	]I_DOG
RMU[FaK]JNV_HKLDTDJN[DG\	FTE4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4WXYWTIF]KD_PMJLWN]MR_MV[MPZSGFJRM[OL[JKLP4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cPZSGFJRM[O_UMYGNJ\
	X_RM[E4XLIKRVXQSYNL[YaL[NR_][a]_RR\_]USF]
TFJD
_UMYGNJ\
PZSGFJRM[O4WXyrq|rmeaaM]XaIMI

\G\\a
cXLIKRVXQSYXLIKRVXQSYPZSGFJRM[OYWTIF]KD_PXLIKRVXQSYL[JKLP4C44C4C4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cSF]
TFJD
RMU[FaK]JNV_HKLDTDJN[DG\	FTE4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE44WXYWTIF]KD_Pyrq|rmeaaM]XaXUWXXXT
OYac_LL_GRYN[aTSQUDQ

D	]I_DOG
_LL_GbbbPZSGFJRM[OL[JKLP44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cPZSGFJRM[O_UMYGNJ\
	X_RM[E4XLIKRVXQSYNL[YaL[NR_][a]_RR\_]UIQ[
HR_
SF]
TFJD
PZSGFJRM[O4WXyrq|rmeaaM]XaIMI

\G\\a
cXLIKRVXQSYXLIKRVXQSYPZSGFJRM[OYWTIF]KD_PXLIKRVXQSYL[JKLP4C4C444C4L[JKLPRMU[FaK]JNV_HK4444C4XKP]JWQPUKR
aLa
VR__FLPXXU[INGT
J]4E444WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]BByrq|rmeaaM]Xa_K_QN_\W	a]a	cXXU[INGT
J]D	]I_DOG

X_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	cXXU[INGT
J]RYN[aTSQUDQ
X_RM[L[JKLPX_RM[4444WXyrq|rmeaaM]XaVRFQ]YMYDD]a

c_UMYGNJ\
XXU[INGT
J]LDTDJN[DG\	FTE4444XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE44WXYWTIF]KD_Pyrq|rmeaaM]Xa]HN[Q	\\KPOVacPZSGFJRM[OJLK[L[JKLPJLK[4C4C44WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cD	]I_DOG
XXU[INGT
J]LDTDJN[DG\	FTE4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4WXYWTIF]KD_PMJLWN]MR_MV[MPZSGFJRM[OL[JKLPJLK[4C4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cPZSGFJRM[OXYTW[WWPHJQ_
	X_RM[]QPJWPK[444XLIKRVXQSYNL[YaL[NR_][a]_RR\_]UXYTW[WWPHJQ_
XYTW[WWPHJQ_
PZSGFJRM[O4WXyrq|rmeaaM]XaIMI

\G\\a
cXLIKRVXQSYXLIKRVXQSYPZSGFJRM[OYWTIF]KD_PXLIKRVXQSYL[JKLPJLK[4444C4C4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cD	]I_DOG
XXU[INGT
J]LDTDJN[DG\	FTE4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4WXYWTIF]KD_Pyrq|rmeaaM]XaXUWXXXT
OYac_LL_GRYN[aTSQUDQ

	SF]
TFJD
_LL_GbbbPZSGFJRM[OL[JKLPJLK[4C4XQL[_]VLDTDJN[DG\	FTec_MPZSGFJRM[OE4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cPZSGFJRM[O_UMYGNJ\
	X_RM[]QPJWPK[4XLIKRVXQSYNL[YaL[NR_][a]_RR\_]UD	]I_DOG
XYTW[WWPHJQ_
PZSGFJRM[O4WXyrq|rmeaaM]XaIMI

\G\\a
cXLIKRVXQSYXLIKRVXQSYPZSGFJRM[OYWTIF]KD_PXLIKRVXQSYL[JKLPJLK[4C4C4L[JKLPX_RM[4C4444XKP]JWQPNTVQ
MOI_UDNY[WULRXXU[INGT
J]444E444WXyrq|rmeaaM]XaIMI

\G\\a
cXXU[INGT
J]BBXXU[INGT
J]L[JKLP4L[JKLPyrq|rmeaaM]Xa_[
SWPR]Nac_UMYGNJ\	
yrq|rmeaaM]Xa[NP\	U	acXXU[INGT
J]
	]IFHJ	W_M]IFHJ	W_Mec4C4XKP]JWQPOQHNJOXU

GHKPDODNOF_PN[NTPVHLPNDPMIPMH_U
D[N	FYQMQYPKRR4E4444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBBDODNOF_PN[NTPVHL[JKLPDODNOF_PN[NTPVH4444QLQI\UXH[QX_IQ[
HR_	LPNDPMIPMHRYN[aTSQUDQ
	
44VGaX
KNKaFQY4DI\IOYVJ444IVWR[DI\IOYVJF]F
E444IR\RPRQ
T[Q\Nyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHQLQI\UXH[QX_4WXIR\RPRQ
T[Q\NX_RM[\L[_U4IKOFUW	XSOLIR\RPRQ
T[Q\Nyrq|rmeaaM]XaNJ]SSODDIGGaacQLQI\UXH[QX_4444IGUYaXaDTyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHD	]I_DOG
IKOFUW	XSOL4WXIGUYaXaDTX_RM[BBIGUYaXaDTIKOFUW	XSOL 
E444VGaX
KNKaFQYyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIKOFUW	XSOL4DODNOF_PN[NTPVHyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIKOFUW	XSOL4]QPJWPK[4444C4TPNJRGHaGVyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIKOFUW	XSOLIGUYaXaDTIKOFUW	XSOL44WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_
TPNJRGHaGVE4VGaX
KNKaFQYyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIKOFUW	XSOL4DODNOF_PN[NTPVHyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIKOFUW	XSOL4]QPJWPK[4C4UO	TKDISMIQ[
HR_	LPNDPMIPMHD	]I_DOG
TPNJRGHaGVXYTW[WWPHJQ_
4VXMTU[HUS][yrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHUO	TKDISMIGUYaXaDT4WXVXMTU[HUS][X_RM[\L[_U4VGaX
KNKaFQYyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIR\RPRQ
T[Q\N4LGLZ_UYa
yrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHIR\RPRQ
T[Q\NVXMTU[HUS][yrq|rmeaaM]XaNJ]SSODDIGGaacUO	TKDISMIR\RPRQ
T[Q\N444WX_U
D[N	FYQMQYPKRRE4WGIQa[KKMIyrq|rmeaaM]XaUQHVIIDGac_U
D[N	FYQMQYLGLZ_UYa
4WXyrq|rmeaaM]XaIMI

\G\\a
cWGIQa[KKMIVGaX
KNKaFQYWGIQa[KKMI4C[RM[E4VGaX
KNKaFQYLGLZ_UYa
4C4DODNOF_PN[NTPVHyrq|rmeaaM]Xa[NP\	U	acDODNOF_PN[NTPVHVXMTU[HUS][yrq|rmeaaM]XaNJ]SSODDIGGaacUO	TKDISM4C4L[JKLPVGaX
KNKaFQYDODNOF_PN[NTPVH4C4XKP]JWQPRWYL
aL\WD__RMU[FaK]JNV_HK444E4L[JKLP444C4XKP]JWQPWLGa\R]QaJRMU[FaK]JNV_HK444E4WXyrq|rmeaaM]XaIMI

\G\\a
cRMU[FaK]JNV_HKL[JKLP444WXZ[XWP[Z_UMYGNJ\

L[JKLPRMU[FaK]JNV_HK444HG[[QKZDDYFJN
WLK\P|mnjv_UMYGNJ\
	44WXyrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOG
HG[[QKZDD_UMYGNJ\
	RMU[FaK]JNV_HKL[JKLP4L[JKLPRMU[FaK]JNV_HK4444C4XKP]JWQPMI_ZS\	HVNP_KKDODNOF_PN[NTPVH4E4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBBDODNOF_PN[NTPVHL[JKLPDODNOF_PN[NTPVH4PLX
MHTUPOQHNJOXU

GHKPDODNOF_PN[NTPVHRYN[aTSQUDQ

_UMYGNJ\
4PLX
MHTUPOQHNJOXU

GHKPPLX
MHTUPRYN[aTSQUDQ

XYTW[WWPHJQ_
4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPPLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\
PLX
MHTUP444WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPPLX
MHTUPDODNOF_PN[NTPVH4WXUKR
aLa
VR__FLPPLX
MHTUPE4444PLX
MHTUPOQHNJOXU

GHKPPLX
MHTUPXYTW[WWPHJQ_
XYTW[WWPHJQ_
4PLX
MHTUPOQHNJOXU

GHKPPLX
MHTUPIQ[
HR_
D	]I_DOG
4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPPLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_
PLX
MHTUP4C4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPPLX
MHTUPDODNOF_PN[NTPVH4C4XKP]JWQPXRYXJDM_PDODNOF_PN[NTPVH4E4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBBZ[XWP[Z_UMYGNJ\

L[JKLPX_RM[4WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_
DODNOF_PN[NTPVHL[JKLPJLK[4]]S_KTWKUSYFJN
WLK\P|mnjvD	]I_DOG
FF4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cRYN[aTSQUDQ


DODNOF_PN[NTPVHXRIZO\]NZTWZVE4XQL[_]VXRIZO\]NZTWZVec_MGVRaJQOT	KPE44WXyrq|rmeaaM]Xa[NP\	U	acGVRaJQOT	KPFF
]]S_KTWKUSL[JKLPJLK[4C4C4aZZyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac|mnjvIQ[
HR_
	4444WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cIQ[
HR_
DODNOF_PN[NTPVHaZSE4XQL[_]VaZSec_MN
KG[S
VE4WXN
KG[S
VaZZL[JKLPJLK[4C4C4L[JKLPX_RM[4C4444XKP]JWQP]WGT_a[U[DS\HFV4444E4WXWMM[Jay{jeXYTW[WWPHJQ_
	cBByrq|rmeaaM]XaIMI

\G\\a
cay{jeXYTW[WWPHJQ_
	cBByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

L[JKLP4K[\IIOSJ~Y[JaQNJWQPIQ[
HR_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJL[JKLP444QaIW
KaMJLWPYay{jeD	]I_DOG
	c4SPHWXWK_LL_G4WXWMM[JK[\IIOSJeJcSPHWXWKecMJLWPYK[\IIOSJeJc4WXWMM[JK[\IIOSJe_UMYGNJ\
cyrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJeXYTW[WWPHJQ_
cE4XQL[_]VK[\IIOSJeIQ[
HR_
c_M]PXIXKKPXE4WXyrq|rmeaaM]Xa]HYHVUa
c]PXIXKKPXWMM[J]PXIXKKPXeJcSPHWXWKecMJLWPY]PXIXKKPXeJc4C4C4MPGO	FQX_RM[4XQL[_]VSPHWXWK_M\	K	]NHE4WX\	K	]NH]QPJWPK[4444MPGO	FQyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

V_MVa[OK_RM\	K	]NHQaIW
Ka\	K	]NHQaIW
Ka44WXMPGO	FQ\L[_U4C4WXMPGO	FQL[JKLP4444yrq|rmeIQ[
HR_

cQaIW
Ka4444\GXT\HI_L]RN_UMYGNJ\
D	]I_DOG

4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG

E4yrq|rmeaaM]XaKQTGQ
Na	cRYN[aTSQUDQ


4C4C444XKP]JWQPLP_a\DKMKYF]ZLTR__44E4WX[SNJGyrq|rme_UMYGNJ\

cBByrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeIQ[
HR_


cL[JKLP4WX[SNJGyrq|rmeXYTW[WWPHJQ_

cL[JKLP4yrq|rmeRYN[aTSQUDQ


cJLK[44[]VQbPm}uyrq|rmeIQ[
HR_


cSF]
TFJD

4C4XKP]JWQP\LWJOZ[QaDUG4E4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD

	L[JKLPX_RM[4]IFHJ	W_M~Y[JaQNJWQPD	]I_DOG
4WXyrq|rmeaaM]XaIMI

\G\\a
c]IFHJ	W_MBByrq|rmeaaM]Xa_K_QN_\W	a]a	c]IFHJ	W_M_UMYGNJ\

L[JKLPX_RM[44DaH_O_	ZJFLWPJyrq|rmeaaM]Xa[NP\	U	ac]IFHJ	W_M4WXDaH_O_	ZJFLyrq|rmeaaM]XaD]SGTYaFPQHDacDaH_O_	ZJFL L[JKLPX_RM[4L[JKLPJLK[444C4XKP]JWQPGXLa_NLOL_PNIZPaYMYD_DJOTFZUQT	4E4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_

L[JKLPX_RM[44K[\IIOSJ~Y[JaQNJWQPXYTW[WWPHJQ_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJK[\IIOSJ_LL_G4WXWMM[JK[\IIOSJeD	]I_DOG
cBByrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJeSF]
TFJD
cE4IT\HGZUXF_FGK_LL_G4WXWMM[JK[\IIOSJeJcK[\IIOSJeNcK[\IIOSJe\cE4OR_JY	SF[MPMJLWPYK[\IIOSJeNc4QWZW\YN\J]W\SMJLWPYK[\IIOSJe\c4IT\HGZUXF_FGKeyrq|rmeaaM]XaaQKLGJP]_OIacOR_JY	SF[MPc_LL_GJ MJLWPYK[\IIOSJeJcN OR_JY	SF[MP\ QWZW\YN\J]W\SSF]
TFJD

 WMM[JK[\IIOSJeIQ[
HR_
cWPJK[\IIOSJeRYN[aTSQUDQ

cyrq|rmeaaM]XaD]SGTYaFPQHDac_UMYGNJ\
 P ~yrq|rmeaaM]XaJSJX
DZZNIIJacQWZW\YN\J]W\SWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acQWZW\YN\J]W\S4MZ
[DPaGFyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~SZaXWR[OR_JY	SF[MPX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cMZ
[DPaGFMZ
[DPaGFIT\HGZUXF_FGKeyrq|rmeaaM]XaaQKLGJP]_OIacOR_JY	SF[MPceVcMZ
[DPaGF4KPM[JOR_JY	SF[MPQWZW\YN\J]W\SMZ
[DPaGF4C444K[\IIOSJ_LL_GRYN[aTSQUDQ

 IT\HGZUXF_FGK4C4TPNJRGHaGVyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_D444VMSV\KP
[Q	\LWJOZ[QaDUG4NNLGLM[WMM[JK[\IIOSJeIQ[
HR_
ceTPNJRGHaGVc44WXNNLGLM[E4444K[\IIOSJeRYN[aTSQUDQ

ceTPNJRGHaGVceIQ[
HR_

cyrq|rmeaaM]XaD]SGTYaFPQHDac4K[\IIOSJe_UMYGNJ\
ceTPNJRGHaGVceYcyrq|rmeaaM]XaZRTJRVaacJLK[4K[\IIOSJeD	]I_DOG
ceTPNJRGHaGVceRYN[aTSQUDQ

c4K[\IIOSJe_UMYGNJ\
ceTPNJRGHaGVcePcJOTFZUQT	4K[\IIOSJe_UMYGNJ\
ceTPNJRGHaGVceIQ[
HR_
cVMSV\KP
[Q	44K[\IIOSJe_UMYGNJ\
ceTPNJRGHaGVceRYN[aTSQUDQ

cyrq|rmeaaM]XaD]SGTYaFPQHDac4K[\IIOSJeRYN[aTSQUDQ

	ceTPNJRGHaGVceIQ[
HR_
c4K[\IIOSJeSF]
TFJD
	ceTPNJRGHaGVceXYTW[WWPHJQ_
c4444K[\IIOSJeRYN[aTSQUDQ

	ceTPNJRGHaGVceSF]
TFJD
c4WXTO[]UPZVQVUTYTK[\IIOSJeIQ[
HR_
	ceTPNJRGHaGVce\cJOTFZUQT	E4444QWVIDDHOPHQ[VKZM_UMYGNJ\
SF]
TFJD
4L[JKLPX_RM[444C4444C[RM[E44WXyrq|rmeaaM]XaOG\FSVKacK[\IIOSJeSF]
TFJD
c 	E4QWVIDDHOPHQ[VKZM_UMYGNJ\
D	]I_DOG

4L[JKLPX_RM[4C4ZFNXLaR
WNWJSWMGUOK\T\L]4F]ZT
P\M]ZFNXLaR
WNWJSWD	]I_DOG
YFJN
WLK\PNIZPaYMYD_DRYN[aTSQUDQ

4WXTO[]UPZVQVUTYTF]ZT
P\M]JOTFZUQT	E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_
IQ[
HR_
	4L[JKLPX_RM[4C4K[\IIOSJeXYTW[WWPHJQ_
ceTPNJRGHaGVc_LL_GJ []a]TFY
DDKXF]F
N NIZPaYMYD_D\ F]ZT
P\M]SF]
TFJD

 yrq|rmeaaM]XaD]SGTYaFPQHDacY yrq|rmeaaM]XaZRTJRVaacJLK[XYTW[WWPHJQ_
 P JOTFZUQT	XYTW[WWPHJQ_
 VMSV\KP
[Q	XYTW[WWPHJQ_
 yrq|rmeaaM]XaD]SGTYaFPQHDacRYN[aTSQUDQ

	 D	]I_DOG
 RYN[aTSQUDQ

 4C4MWYSNFX_J~KNZ_J[aQNJWQPD	]I_DOG
K[\IIOSJSF]
TFJD	44WXMWYSNFX_JE4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
	~INa]_]V[aZ[R[J[D	]I_DOG
XYTW[WWPHJQ_
4[\WH]\	FFD~Y[JaQNJWQPXYTW[WWPHJQ_
_LL_G4HYNMHYUSKNGyrq|rmeaaM]Xa]HYHVUa
c[\WH]\	FFDWMM[J[\WH]\	FFDeD	]I_DOG
ceTPNJRGHaGVcyrq|rmeaaM]Xa]HYHVUa
c[\WH]\	FFDeRYN[aTSQUDQ

	ceTPNJRGHaGVc4WMM[J[\WH]\	FFDe_UMYGNJ\
	ceTPNJRGHaGVceYcMJLWPY[\WH]\	FFDeXYTW[WWPHJQ_
	ceTPNJRGHaGVceYcMJLWPYK[\IIOSJeIQ[
HR_
	ceTPNJRGHaGVceYc4WXHYNMHYUSKNGE4WXNNLGLM[_I	Q]G
P
K[\IIOSJeRYN[aTSQUDQ

	ceTPNJRGHaGVce\c4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ

XYTW[WWPHJQ_
	
44L[JKLPX_RM[4C4C4444yrq|rmeaaM]XaKQTGQ
Na	c_UMYGNJ\
	4L[JKLPJLK[4C44XKP]JWQPIGGQI[HLH[X]aIFN]LOV4E4WXWMM[Jyrq|rmeD	]I_DOGcBByrq|rmeaaM]XaXJ	S]
XXOa
	cyrq|rmeIQ[
HR_cyrq|rmeSF]
TFJDc4L[JKLPyrq|rmeSF]
TFJD
		c444C4XKP]JWQPSF]Q_FWSLT\DJM	VWHJO\JM\Q	L4E4yrq|rmeD	]I_DOG
		cWMM[Jyrq|rmeIQ[
HR_
		cyrq|rmeaaM]XaXJ	S]
XXOa
	cyrq|rmeSF]
TFJD
	cyrq|rme_UMYGNJ\
	cXRQ_JVWHJO\JM\Q	L44C4444XKP]JWQPa	N]NKU_VUWZ\
LWYKJFNPOZO]QQ4E4Q]LYQNN	YQ
MJIGGQI[HLH[X]aIFN]LOV444WXQ]LYQNN	YQ
MJL[JKLP_LL_G4ZVOP
XVM	_yrq|rmeaaM]XaWFGGDF

Ma
	cyrq|rmeaaM]XaZSHITKKZFa
	cWPJQ]LYQNN	YQ
MJ4ODMWaT]Oa]RLMyrq|rmeaaM]XaZRTJRVaacJLK[4P]OWKL[WR[~yrq|rmeaaM]Xa\aLGRF
acJFNPOZO]QQ_LL_G_UMYGNJ\		 ZVOP
XVM	_XYTW[WWPHJQ_
	 X_RM[XYTW[WWPHJQ_
	 JLK[IQ[
HR_ D	]I_DOG FX\Z]F_

D	]I_DOG	 _LL_GRYN[aTSQUDQ
	
 IQ[
HR_
D	]I_DOG
 _UMYGNJ\
4SF]Q_FWSLT\DJM	yrq|rmeaaM]XaZRTJRVaacJLK[ODMWaT]Oa]RLM4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
WMaINa[LLQLP]OWKL[WR[L[JKLP_LL_GX_RM[4SJPQN	QRyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_

WPJINaL[SQJ[aL[JLW[H[aL[MNQPM[a]QZ[P]OWKL[WR[4L[JKLP_LL_GSJPQN	QRSJPQN	QR yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
MJLWPYINaL[SQJ[aL[JLW[H[a\QZGP]OWKL[WR[4C4XKP]JWQPWUUIP	M_XOZKJ	YHTNIZPaYMYD_D4E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
BByrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\BByrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
L[JKLP444K[\IIOSJ~Y[JaQNJWQPIQ[
HR_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJBBWMM[JK[\IIOSJeIQ[
HR_
	cBByrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJeD	]I_DOG
	cL[JKLP444TPNJRGHaGVyrq|rmeaaM]XaaQKLGJP]_OIacNIZPaYMYD_D4444WXWMM[JK[\IIOSJeIQ[
HR_
	ceTPNJRGHaGVcL[JKLP44DU[L[YMZaMYFW~SZaXWR[NIZPaYMYD_D4WXyrq|rmeaaM]XaIMI

\G\\a
cDU[L[YMZaMYFWBBDU[L[YMZaMYFWL[JKLP4K[\IIOSJeD	]I_DOG
	ceTPNJRGHaGVceVcDU[L[YMZaMYFW4~KNZ_J[aQNJWQPXYTW[WWPHJQ_
K[\IIOSJXYTW[WWPHJQ_
4C444XKP]JWQPH
HDLJ]NS
a_NWLT]PXIXKKPX4E4aaGQYVJMa_PQQ~yrq|rmeaaM]XaHSO\NMa_Da
c]PXIXKKPXe\c4444WXyrq|rmeaaM]XaIMI

\G\\a
caaGQYVJMa_PQQL[JKLPX_RM[4WX[SNJG]PXIXKKPXeVcyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

E4\[HP]ML~SZaXWR[]PXIXKKPXeNc4WXyrq|rmeaaM]XaIMI

\G\\a
c\[HP]ML\[HP]ML\[HP]ML]PXIXKKPXeVcL[JKLPX_RM[4KPM[J\[HP]ML4C4WXaaGQYVJMa_PQQE4444WX[SNJG]PXIXKKPXePcL[JKLPX_RM[4SL
]KPRGW~yrq|rmeaaM]XaJSJX
DZZNIIJac]PXIXKKPXeNc4WXSL
]KPRGWE4Y_HVRRKFFH]X
]VL
R]PXIXKKPXeNc
4SL
]KPRGW_I	Q]G
P
]PXIXKKPXeNc4C4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~QN]_]V[aWPH_RWZ_J[]PXIXKKPXeNcJLK[4L[JKLPSL
]KPRGW4444C4WXTO[]UPZVQVUTYT]PXIXKKPXeNcaaGQYVJMa_PQQL[JKLPX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~QN]_]V[aWPH_RWZ_J[]PXIXKKPXeNcJLK[4L[JKLPJLK[444C4XKP]JWQPNO_]FJTNIFFRG4E4444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
L[JKLP4WX[SNJGyrq|rmeIQ[
HR_cL[JKLP4444WXZPO_XHQ_]L_ZXYTW[WWPHJQ_
L[JKLP4JLGE4K[\IIOSJ~Y[JaQNJWQPIQ[
HR_
_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJL[JKLP44WXWMM[JK[\IIOSJeRYN[aTSQUDQ

	cBByrq|rmeaaM]Xa]HYHVUa
cK[\IIOSJeRYN[aTSQUDQ

cE4IT\HGZUXF_FGK_LL_G4WXWMM[JK[\IIOSJeJcK[\IIOSJeNcK[\IIOSJe\cE4OR_JY	SF[MPMJLWPYK[\IIOSJeNc4QWZW\YN\J]W\SMJLWPYK[\IIOSJe\c4IT\HGZUXF_FGKeyrq|rmeaaM]XaaQKLGJP]_OIacOR_JY	SF[MPc_LL_GJ MJLWPYK[\IIOSJeJcN OR_JY	SF[MP\ QWZW\YN\J]W\SIQ[
HR_

 WMM[JK[\IIOSJeIQ[
HR_

cWPJK[\IIOSJeRYN[aTSQUDQ

cyrq|rmeaaM]XaD]SGTYaFPQHDacIQ[
HR_
 P ~yrq|rmeaaM]XaJSJX
DZZNIIJacQWZW\YN\J]W\SWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acQWZW\YN\J]W\S444MZ
[DPaGFyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
~SZaXWR[OR_JY	SF[MPX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cMZ
[DPaGFMZ
[DPaGFIT\HGZUXF_FGKeyrq|rmeaaM]XaaQKLGJP]_OIacOR_JY	SF[MPceVcMZ
[DPaGF44KPM[JOR_JY	SF[MPQWZW\YN\J]W\SMZ
[DPaGF4C4K[\IIOSJ_LL_GSF]
TFJD
 IT\HGZUXF_FGK4C4WX[SNJGK[\IIOSJe_UMYGNJ\
cE4~Z[R[J[aQNJWQPRYN[aTSQUDQ

4L[JKLP4C444WX\LWJOZ[QaDUGE4SFNaU		TLTX_RM[4XQL[_]VK[\IIOSJeD	]I_DOG
c_M_ZR__KFSX]W KG_ITPGOIUaUE4WXyrq|rmeaaM]Xa]HYHVUa
cKG_ITPGOIUaU[SNJGKG_ITPGOIUaUe_UMYGNJ\
cE4K[\IIOSJe_UMYGNJ\
ce_ZR__KFSX]WceSF]
TFJD

c4SFNaU		TLTJLK[4444C4C4WXSFNaU		TLT~KNZ_J[aQNJWQPIQ[
HR_
K[\IIOSJ_UMYGNJ\
4KPM[JSFNaU		TLT_ZR__KFSX]WKG_ITPGOIUaU4L[JKLP4C4MJ_JW]YDH_XaWWDKFX_RM[4WXYDH_XaWWDKFL[JKLP4YDH_XaWWDKFJLK[4D_aG]IIR
PXQMIyrq|rmeaaM]XaW_	L\NQ_
Va	cK[\IIOSJeIQ[
HR_
c4TQNJJHOL_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~yrq|rmeaaM]XaPT[N\H_\U	LXac4[RM[WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~yrq|rmeaaM]XaTWRSTN
\YG
\a
c4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~yrq|rmeaaM]XaMHSN\]HKXIacJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
	BByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

L[JKLP4ZRQN	WMZWIVQS[aKLR4JWJ
]Y\KW\XX
yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
INaRQYWPaKLRZRQN	WMZWIRYN[aTSQUDQ

444QLWQOKMWSLKNOX_RM[4PVGNLDM_[KJLK[444Q]LYQNN	YQ
MJ`	4XQL[_]VK[\IIOSJeXYTW[WWPHJQ_c_MTPNJRGHaGV ]PXIXKKPXE4WXIGGQI[HLH[X]aIFN]LOV\L[_U4WXyrq|rmeaaM]Xa]HYHVUa
c]PXIXKKPXBB[SNJG]PXIXKKPXeJcBB[SNJG]PXIXKKPXeNcBB[SNJG]PXIXKKPXe\cE4KPM[JK[\IIOSJeRYN[aTSQUDQ
ceTPNJRGHaGVc4QLWQOKMWSLKNOJLK[4]QPJWPK[4C4WXWMM[J]PXIXKKPXePcBBWMM[J]PXIXKKPXeVcE4WXWMM[J]PXIXKKPXePc]PXIXKKPXePc~yrq|rmeaaM]XaJSJX
DZZNIIJac]PXIXKKPXe\cWPJ~yrq|rmeaaM]XaNDD_U_S]R\\ac]PXIXKKPXe\c4WXWMM[J]PXIXKKPXeVcyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
E4JXNK\HLH~SZaXWR[]PXIXKKPXeNc44WXyrq|rmeaaM]XaIMI

\G\\a
cJXNK\HLHJXNK\HLH]PXIXKKPXeVcJXNK\HLH4KPM[JJXNK\HLH4C4K[\IIOSJeIQ[
HR_ceTPNJRGHaGVc]PXIXKKPX4QLWQOKMWSLKNOJLK[4C4WX[SNJG]PXIXKKPXeXYTW[WWPHJQ_cE4]PXIXKKPXeIQ[
HR_c4]PXIXKKPXe_UMYGNJ\
cyrq|rmeaaM]XaD]SGTYaFPQHDac4]PXIXKKPXe_UMYGNJ\c444]PXIXKKPXeD	]I_DOG
	c4444]PXIXKKPXeXYTW[WWPHJQ_
c4]PXIXKKPXeSF]
TFJD
c4K[\IIOSJeXYTW[WWPHJQ_ceTPNJRGHaGVc]PXIXKKPX4QLWQOKMWSLKNOJLK[4C4WX[SNJG]PXIXKKPXeD	]I_DOG
cE4K[\IIOSJeSF]
TFJDceTPNJRGHaGVceRYN[aTSQUDQ

cWPJ]PXIXKKPXeSF]
TFJD
c4]PXIXKKPXeIQ[
HR_
cWPJ]PXIXKKPXeD	]I_DOG
c4QLWQOKMWSLKNOJLK[4444C4WX[SNJG]PXIXKKPXeXYTW[WWPHJQ_cyrq|rmeaaM]XaD]SGTYaFPQHDacWPJ]PXIXKKPXeD	]I_DOGc]QPJWPK[44WXQ]LYQNN	YQ
MJ\L[_U4444Q]LYQNN	YQ
MJ4JSX]LM[U[XTTW
XYTW[WWPHJQ_	yrq|rmeaaM]XaHGUUYZFXR	NIac]PXIXKKPXeJcXYTW[WWPHJQ_yrq|rmeaaM]XaFL_RINU
a
c4RWMJSJPQN	QRZXUa	YXGKa	N]NKU_VUWZ\
LWYKZRQN	WMZWIJSX]LM[U[XTTW
4WXSJPQN	QR\L[_U4WXSJPQN	QR PVGNLDM_[KX_RM[4WXSJPQN	QRyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\IGGQI[HLH[X]aIFN]LOV yrq|rmeaaM]XaZUTOXXQaQac4WXSJPQN	QRE4RWMJSJPQN	QRZXUa	YXGKa	N]NKU_VUWZ\
LWYKZRQN	WMZWIJSX]LM[U[XTTW
4WXSJPQN	QR\L[_U4WXSJPQN	QR PVGNLDM_[KX_RM[4C4WXSJPQN	QRE444K[\IIOSJeD	]I_DOGceTPNJRGHaGVceSF]
TFJDc4QLWQOKMWSLKNOJLK[4]QPJWPK[4C4WXSJPQN	QR 

E44WXH
HDLJ]NS
a_NWLT]PXIXKKPXE4QWVIDDHOPHQ[VKZMIQ[
HR_
RYN[aTSQUDQ
yrq|rmeaaM]Xa[KDO
YMUaR\Vac]PXIXKKPXeNc4TQNJJHOLeTPNJRGHaGVc]PXIXKKPX4KPM[JK[\IIOSJeSF]
TFJDceTPNJRGHaGVc4C[RM[E4K[\IIOSJeD	]I_DOGceTPNJRGHaGVceIQ[
HR_c444C4QLWQOKMWSLKNOJLK[4444]QPJWPK[4C44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cZXUa	YXGKD	]I_DOG]PXIXKKPXeJcSF]
TFJD

X_RM[E4444TQNJJHOLeTPNJRGHaGVc]PXIXKKPX4KPM[JK[\IIOSJeIQ[
HR_ceTPNJRGHaGVc4QLWQOKMWSLKNOJLK[4]QPJWPK[444C444RWMJL_ZQF[
NI		DVGDGaUZQLWa	N]NKU_VUWZ\
LWYKJWJ
]Y\KW\XX
yrq|rmeaaM]Xa_K_QN_\W	a]a	cJWJ
]Y\KW\XX
X_RM[RYN[aTSQUDQ
yrq|rmeaaM]XaHGUUYZFXR	NIac]PXIXKKPXeJcXYTW[WWPHJQ_yrq|rmeaaM]XaFL_RINU
a
c
	
	4444WXL_ZQF[
NI		DV\L[_U444WXL_ZQF[
NI		DV PVGNLDM_[KX_RM[4WXL_ZQF[
NI		DV 
	E4WXH
HDLJ]NS
a_NWLT]PXIXKKPXE4QWVIDDHOPHQ[VKZM_UMYGNJ\
_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\Vac]PXIXKKPXeNc4TQNJJHOLeTPNJRGHaGVc]PXIXKKPX444KPM[JK[\IIOSJeSF]
TFJDceTPNJRGHaGVc4C[RM[E4K[\IIOSJeRYN[aTSQUDQ
ceTPNJRGHaGVceXYTW[WWPHJQ_c4C444QLWQOKMWSLKNOJLK[44]QPJWPK[4444C4WXyrq|rmeaaM]XaIMI

\G\\a
cGDGaUZQLWyrq|rmeaaM]Xa_K_QN_\W	a]a	cGDGaUZQLWXYTW[WWPHJQ_]PXIXKKPXeJcD	]I_DOG

X_RM[E4TQNJJHOLeTPNJRGHaGVc]PXIXKKPX4KPM[JK[\IIOSJeXYTW[WWPHJQ_ceTPNJRGHaGVc4QLWQOKMWSLKNOJLK[4]QPJWPK[4C4K[\IIOSJeRYN[aTSQUDQ
ceTPNJRGHaGVce_UMYGNJ\
	cWPJWMM[JK[\IIOSJeD	]I_DOGceTPNJRGHaGVce_UMYGNJ\	cK[\IIOSJeD	]I_DOGceTPNJRGHaGVce_UMYGNJ\	c4WXyrq|rmeaaM]XaD]SGTYaFPQHDacWPJK[\IIOSJeXYTW[WWPHJQ_ceTPNJRGHaGVceSF]
TFJD
c 
E4K[\IIOSJeD	]I_DOGceTPNJRGHaGVce_UMYGNJ\
c4K[\IIOSJeIQ[
HR_ceTPNJRGHaGVce_UMYGNJ\cyrq|rmeaaM]XaD]SGTYaFPQHDacFX_]FZ
4C[RM[E4444VLL[	_V\KN_LL_G`				4DUZZ\	XIWPJK[\IIOSJeSF]
TFJDceTPNJRGHaGVceXYTW[WWPHJQ_	c4K[\IIOSJe_UMYGNJ\ceTPNJRGHaGVceXYTW[WWPHJQ_cyrq|rmeaaM]XaD]SGTYaFPQHDacVLL[	_V\KNeyrq|rmeaaM]XaZSHITKKZFa
	cDUZZ\	XI`c4KPM[JVLL[	_V\KNDUZZ\	XI4C44QLWQOKMWSLKNOJLK[4C4WXPVGNLDM_[KQLWQOKMWSLKNO[SNJGK[\IIOSJeSF]
TFJDcE4T\TX\MMGLX_RM[4XQL[_]VK[\IIOSJeXYTW[WWPHJQ_c_MPaMF]YTKJE4WXWPJPaMF]YTKJe_UMYGNJ\c FFE4T\TX\MMGLJLK[444\L[_U4C4C4WXT\TX\MMGLE4~KNZ_J[aQNJWQPIQ[
HR_IQ[
HR_yrq|rmeaaM]XaD]SGTYaFPQHDac_UMYGNJ\
4QWVIDDHOPHQ[VKZMSF]
TFJD
D	]I_DOG
4XQL[_]VK[\IIOSJe_UMYGNJ\c_M]N]L	LM	M PaMF]YTKJE4WXyrq|rmeaaM]Xa]HYHVUa
cPaMF]YTKJ[SNJGPaMF]YTKJeD	]I_DOGcK[\IIOSJeXYTW[WWPHJQ_ce]N]L	LM	MceIQ[
HR_c4C4QLWQOKMWSLKNOJLK[4C4C[RM[WXPVGNLDM_[KE444S[NG	LIO_~Y[JaQNJWQPSF]
TFJD4WXyrq|rmeaaM]XaIMI

\G\\a
cS[NG	LIO_BByrq|rmeaaM]Xa_K_QN_\W	a]a	cS[NG	LIO_RYN[aTSQUDQ
	~KNZ_J[aQNJWQPXYTW[WWPHJQ_XYTW[WWPHJQ_	yrq|rmeaaM]XaD]SGTYaFPQHDacXYTW[WWPHJQ_
4C4WXQLWQOKMWSLKNOE44WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
	~INa]_]V[aZ[R[J[IQ[
HR_
SF]
TFJD4DU\_
_T
]~Y[JaQNJWQPD	]I_DOG
_LL_G44WXyrq|rmeaaM]Xa]HYHVUa
cDU\_
_T
]WMM[JDU\_
_T
]eRYN[aTSQUDQ
cyrq|rmeaaM]Xa]HYHVUa
cDU\_
_T
]eRYN[aTSQUDQ
cE4XQL[_]VDU\_
_T
]e_UMYGNJ\c_MFOO]GIDINWHYN G_I_YHWE44WXWMM[JK[\IIOSJeSF]
TFJDceFOO]GIDINWHYNc]QPJWPK[4WXyrq|rmeaaM]Xa_LHMQPFPD
Ma
cFOO]GIDINWHYND_aG]IIR
PXQMIJLK[E4K[\IIOSJeRYN[aTSQUDQ
ceFOO]GIDINWHYNcG_I_YHW4]QPJWPK[4C4444WXWMM[JTQNJJHOLeFOO]GIDINWHYNcyrq|rmeaaM]Xa]HYHVUa
cG_I_YHWE4\X	aDVWNIN\[LDWMM[JG_I_YHWeYcXRQ_JG_I_YHWeYcXRQ_JWMM[JG_I_YHWeRYN[aTSQUDQ

cG_I_YHWeRYN[aTSQUDQ

c444YRJNQVM]D	TMMWMM[JTQNJJHOLeFOO]GIDINWHYNceYcXRQ_JTQNJJHOLeFOO]GIDINWHYNceYcXRQ_JWMM[JTQNJJHOLeFOO]GIDINWHYNceRYN[aTSQUDQ

cTQNJJHOLeFOO]GIDINWHYNceD	]I_DOG
c444WX\X	aDVWNIN\[LD YRJNQVM]D	TMMK[\IIOSJeSF]
TFJDceFOO]GIDINWHYNcG_I_YHW4KPM[J\X	aDVWNIN\[LDYRJNQVM]D	TMM4C4C4C4KPM[JDU\_
_T
]FOO]GIDINWHYNG_I_YHW4444C4XQL[_]VTQNJJHOL_MJYJWW]F]IF[W XFOY
[TLM\E4WXWMM[JK[\IIOSJeSF]
TFJDceJYJWW]F]IF[Wc_I	Q]G
P
XFOY
[TLM\e\c4C4KPM[JTQNJJHOLJYJWW]F]IF[WXFOY
[TLM\4WX[SNJGK[\IIOSJeRYN[aTSQUDQ
c~Z[R[J[aQNJWQPD	]I_DOG4[RM[WXQLWQOKMWSLKNO~KNZ_J[aQNJWQPSF]
TFJDK[\IIOSJRYN[aTSQUDQ

44CXWP_RRGE4FT_Q_YTVaGTXYTW[WWPHJQ_4C4C4XKP]JWQPHNDKTHQVTMIJHPDODNOF_PN[NTPVH4E4L[JKLPyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHSF]
TFJD
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHSF]
TFJDX_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHIQ[
HR_
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHSF]
TFJD
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHIQ[
HR_X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHIQ[
HR_	X_RM[4C4XKP]JWQPN_]DDSMN]aOZVW_UYMTDODNOF_PN[NTPVH4E4WXHNDKTHQVTMIJHPDODNOF_PN[NTPVHL[JKLPX_RM[4WXUKR
aLa
VR__FLPDODNOF_PN[NTPVHL[JKLPJLK[4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cXYTW[WWPHJQ_DODNOF_PN[NTPVH]IFHJ	W_ME4XQL[_]V]IFHJ	W_Mec_MO\\D	KOFVE4WXH[LMWQPa]QSN_L[O\\D	KOFVRINYW\WDWV_QNR
I	L[JKLPJLK[4C4L[JKLPX_RM[4C444L[JKLPJLK[4C4444XKP]JWQP_Da]D_LX_XTWMT[GZ
F_aLRUKPPPL[4E4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF_aLRUKPPPL[BB~yrq|rmeaaM]XaURRZW
ITGa
cF_aLRUKPPPL[L[JKLP444ZMKUD
~yrq|rmeaaM]XaNDD_U_S]R\\acF_aLRUKPPPL[4WXZMKUD
L[JKLP4WXZMKUD
 
		E4444HSNVNJ_XYGNVV~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[X_RM[PKRR4WXHNDKTHQVTMIJHPHSNVNJ_XYGNVVL[JKLP4WXPWOFFGWURYH]M[F_aLRUKPPPL[X_RM[E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
SF]
TFJD
yrq|rmeaaM]Xa[KDO
YMUaR\VacF_aLRUKPPPL[4L[JKLP44C4~yrq|rmeaaM]XaUM_SDP\\\a
cF_aLRUKPPPL[NVNbP4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_~QN]_]V[aWPH_RWZ_J[F_aLRUKPPPL[JLK[4L[JKLP4C44WXZMKUD
 FX	F	E4VRWMV[aF[F[\MJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[X_RM[PKRR
4VVLSYMN_ZMKUD
 	MJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[X_RM[PKRRZMKUD

4JUMF[RQUFH]VRWMV[aF[F[\VVLSYMN_4WXJUMF[RQUFH]yrq|rmeaaM]XaVRFQ]YMYDD]a

cD	]I_DOG
JUMF[RQUFH]\VK]DWMHPJE4P]TJ	RKDPX_RM[4XQL[_]V\VK]DWMHPJec_MJSIYP_QJ_E4WXH[LMWQPa]QSN_L[JSIYP_QJ_RINYW\WDWV_QNR
I	E444P]TJ	RKDPJLK[4\L[_U4444C4C4WXP]TJ	RKDPL[JKLP4C4444C4444DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cF_aLRUKPPPL[4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHyrq|rmeaaM]XaNJ]SSODDIGGaacDODNOF_PN[NTPVH 
DODNOF_PN[NTPVHT_DLVDPGFPFPaDQRKDODNOF_PN[NTPVH444WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHL[JKLP4WXN_]DDSMN]aOZVW_UYMTDODNOF_PN[NTPVHL[JKLP4J\FFKIUVUOD]WJD	NF_aLRUKPPPL[DODNOF_PN[NTPVH4C4XKP]JWQPJ\FFKIUVUOD]WJD	NF_aLRUKPPPL[DODNOF_PN[NTPVH4444E444PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cD	]I_DOG
DODNOF_PN[NTPVH4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPBByrq|rmeaaM]XaVMQGFWM]acPLX
MHTUPBByrq|rmeaaM]XaVMQGFWM]acPLX
MHTUPIQ[
HR_	PLX
MHTUPNVNbP4444WXyrq|rmeaaM]XaNJ]SSODDIGGaacPLX
MHTUP 

GQS[a	
DD\SGLHVPLX
MHTUPPLX
MHTUPNVNbP4XVYGDGOPSN__[S~XWR[N[LSMF_aLRUKPPPL[4XVYGDGOPSN__[SXVYGDGOPSN__[SX_RM[
XVYGDGOPSN__[S

4ZRROW_ZDD~yrq|rmeaaM]Xa_GRUDISIa	cF_aLRUKPPPL[4UYUa\[DKHVK~yrq|rmeaaM]Xa]QU\]aRRa	cyrq|rmeaaM]Xa]FMXaRDGSQacF_aLRUKPPPL[XYTW[WWPHJQ_
4WXUYUa\[DKHVKX_RM[L[JKLP4WX~yrq|rmeaaM]XaUM_SDP\\\a
cUYUa\[DKHVKPLX
MHTUPyrq|rmeaaM]XaNJ]SSODDIGGaacPLX
MHTUPE4~yrq|rmeaaM]XaYR\Y]GUO[a	cUYUa\[DKHVK4L[JKLP4444C4~yrq|rmeaaM]Xa]]MPGGSWaX]TacUYUa\[DKHVKXVYGDGOPSN__[S4WX~yrq|rmeaaM]XaR
[HRNLSDPHa	
cUYUa\[DKHVKF_aLRUKPPPL[E4~yrq|rmeaaM]XaYR\Y]GUO[a	cUYUa\[DKHVK4L[JKLP4C444WXZRROW_ZDD~yrq|rmeaaM]XaKHLOSPVW]RWJa	cF_aLRUKPPPL[ZRROW_ZDD4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
~QN]_]V[aWPH_RWZ_J[F_aLRUKPPPL[JLK[4C4XKP]JWQPUMNZ\Z[FKXHLSYTXDRMU[FaK]JNV_HK4E4WXyrq|rmeaaM]XaIMI

\G\\a
cRMU[FaK]JNV_HKL[JKLP4WXyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_

RMU[FaK]JNV_HKILG	OaPXLZE4QIQKFOXaHILG	OaPXLZec4ZMKUD
~yrq|rmeaaM]XaJSJX
DZZNIIJacQIQKFOXaH~yrq|rmeaaM]XaNDD_U_S]R\\acQIQKFOXaH4WXZMKUD
BBZMKUD


BBZMKUD
 
	
E4444WXZMKUD
 
	

E4WWXHUUPXXR~yrq|rmeaaM]XaI	WS[XMPacQIQKFOXaH4WXyrq|rmeaaM]XaIMI

\G\\a
cWWXHUUPXXRWWXHUUPXXRQIQKFOXaH4WWXHUUPXXRyrq|rmeaaM]XaXUWXXXT
OYacbbWWXHUUPXXR4[\GRHVaYa\_X_RM[4MD[aQRWTR\_LL_GZ[XWP[ZRYN[aTSQUDQ


yrq|rmeaaM]XaNGLV\SLPGac|mnjvIQ[
HR_Z[XWP[Z_UMYGNJ\yrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwl_UMYGNJ\4XQL[_]VMD[aQRWTR\_MWL	U[XNRE4WL	U[XNRyrq|rmeaaM]XaXUWXXXT
OYacbbWL	U[XNR4WXWL	U[XNRyrq|rmeaaM]Xa_K_QN_\W	a]a	cWWXHUUPXXRWL	U[XNRE4[\GRHVaYa\_JLK[4\L[_U4C4C4WX[\GRHVaYa\_PWOFFGWURYH]M[QIQKFOXaHX_RM[E4~yrq|rmeaaM]XaYR\Y]GUO[a	cQIQKFOXaH4~yrq|rmeaaM]XaYR\Y]GUO[a	cyrq|rmeaaM]Xa]FMXaRDGSQacQIQKFOXaH_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacQIQKFOXaHIQ[
HR_44C[RM[E4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
XYTW[WWPHJQ_
yrq|rmeaaM]Xa[KDO
YMUaR\VacQIQKFOXaH4C4C44L[JKLP4444C4C4444L[JKLPRMU[FaK]JNV_HK4444C4XKP]JWQPY]_ZNYPWNGUIaI4E4MJ_JW]QIQKFOXaHPKRR4WXQIQKFOXaHPKRRE4O\\D	KOFVGUOJ[XOIWQIQ[
HR_	PKRR44WXO\\D	KOFVPKRRE4ZLU	\GGT[GUOJ[XOIWQD	]I_DOG	4O\\D	KOFVyrq|rmeaaM]XaIMI

\G\\a
cZLU	\GGT[yrq|rmeaaM]Xa_K_QN_\W	a]a	cZLU	\GGT[_UMYGNJ\	44SY	]ZUMDJLRRD	]I_DOG
O\\D	KOFVRYN[aTSQUDQ

4KPM[JZLU	\GGT[4C4QIQKFOXaHWPJO\\D	KOFV4C4444L[JKLPQIQKFOXaH4C4XKP]JWQPKW
FXVNDYXM]QQ4E44WXZ[XWP[ZXYTW[WWPHJQ_

L[JKLP4J]YVRPQ[a|mnjv_UMYGNJ\
	444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]YVRPQ[aE4SPOFTIVJNUX	Yyrq|rmeaaM]Xa]FMXaRDGSQac|mnjvIQ[
HR_
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacSPOFTIVJNUX	YJ]YVRPQ[aSPOFTIVJNUX	Y4C4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]YVRPQ[aBB~yrq|rmeaaM]XaURRZW
ITGa
cJ]YVRPQ[aL[JKLP4WWXHUUPXXR~yrq|rmeaaM]XaI	WS[XMPacJ]YVRPQ[a4WXyrq|rmeaaM]XaIMI

\G\\a
cWWXHUUPXXRWWXHUUPXXR~yrq|rmeaaM]XaURRZW
ITGa
cWWXHUUPXXRJ]YVRPQ[aWWXHUUPXXR4WX~yrq|rmeaaM]XaNDD_U_S]R\\acJ]YVRPQ[a 


L[JKLP4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cJ]YVRPQ[a4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHBBDODNOF_PN[NTPVHL[JKLP4KKHDa[	QMyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVH_UMYGNJ\
X_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHD	]I_DOGX_RM[444_	HS[S\T]PY_X_RM[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHXYTW[WWPHJQ_X_RM[E4WX[SNJGyrq|rmeD	]I_DOGcE4_	HS[S\T]PY_JLK[4C[RM[E44FQZaQ[YYMFyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	yrq|rmeaaM]XaFHHDS]ZRTNa	cXYTW[WWPHJQ_	4WX~yrq|rmeaaM]XaS

	ZLD	a
cFQZaQ[YYMFBB~yrq|rmeaaM]XaURRZW
ITGa
cFQZaQ[YYMF_	HS[S\T]PY_JLK[4C4C44MV_\MJSFTYX_RM[4V[XIVN[_[OTX_RM[4WXyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_DODNOF_PN[NTPVHZ[XWP[ZSF]
TFJDE4444a_]ina}qpj{pjazwl_UMYGNJ\4WX~yrq|rmeaaM]XaJSJX
DZZNIIJaca_]E4NIUIRQWRMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
ca_]X_RM[PKRR
	4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cNIUIRQWRRYN[aTSQUDQ

X_RM[MV_\MJSFTYJLK[4C4C[RM[WX4yrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHXYTW[WWPHJQ_X_RM[4yrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOGDODNOF_PN[NTPVH4E4V[XIVN[_[OTJLK[4C444XYFKHPNIUNX_RM[44WXY]_ZNYPWNGUIaIE44WX44yrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_DODNOF_PN[NTPVH4BByrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
	DODNOF_PN[NTPVH4BByrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_DODNOF_PN[NTPVH4XYFKHPNIUNJLK[4C4WXKKHDa[	QM_	HS[S\T]PY_MV_\MJSFTYXYFKHPNIUNV[XIVN[_[OTL[JKLP4G_JOKSMVPR
OHGT\4PLX
MHTUPDODNOF_PN[NTPVH4WXKKHDa[	QME44WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cSF]
TFJDDODNOF_PN[NTPVH]a
LX[WQY]QWG_JOKSMVPR
OHGT\yrq|rmeaaM]XaZ
ZVRO
UNLDKa
cbP]a
LX[WQY]QWec4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_DODNOF_PN[NTPVH4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP4WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_PLX
MHTUPE4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

c_UMYGNJ\PLX
MHTUPDVH\QVIZPHZ
UFG_JOKSMVPR
OHGT\bPyrq|rmeaaM]XaZ
ZVRO
UNLDKa
cbPDVH\QVIZPHZ
UFec4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\PLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP44C444C4VUWII\MZPUQXYTW[WWPHJQ_4WX_	HS[S\T]PY_yrq|rmeaaM]Xa_[
SWPR]NacVUWII\MZPUQPLX
MHTUPE4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_
VUWII\MZPUQIQ[
HR_IQ[
HR_Z[XWP[inaj{snazwlZ[XWP[Zina}qpj{pjazwlina}qpj{pjazwl|mnjvIN]QPJ[PJM]aJSNbPPLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP4C4WXMV_\MJSFTYyrq|rmeaaM]Xa_[
SWPR]NacVUWII\MZPUQPLX
MHTUPE44PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_
VUWII\MZPUQXYTW[WWPHJQ_IQ[
HR_	Z[XWP[ina}}v{JLK[m}ai}bPPLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP444C[RM[WXV[XIVN[_[OTE4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\
VUWII\MZPUQXYTW[WWPHJQ_SF]
TFJD	Z[XWP[ina}}v{JLK[m}ai}bPPLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP4C4WXXYFKHPNIUNE444PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJDPLX
MHTUP44WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP4WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_
VUWII\MZPUQXYTW[WWPHJQ_PLX
MHTUPE4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
	VUWII\MZPUQRYN[aTSQUDQ
IQ[
HR_	Z[XWP[inaz{|kyJLK[bPZ[XWP[inaz{|kyarqyJLK[bPZ[XWP[inaz{|kyazwmnrgX_RM[bPPLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPL[JKLP4C4C4WXPLX
MHTUPDODNOF_PN[NTPVHL[JKLP4WXGQS[a	
DD\SGLHVPLX
MHTUPL[JKLP4WXV[XIVN[_[OTyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~KNZ_J[aQNJWQPSF]
TFJD	D	]I_DOG
4WXMV_\MJSFTYGXLa_NLOL_PJ]YVRPQ[aDODNOF_PN[NTPVHE44QWVIDDHOPHQ[VKZMD	]I_DOG	_UMYGNJ\4PLX
MHTUPyrq|rmeaaM]Xa]H[KYS
JDPXa
cD	]I_DOG	VUWII\MZPUQD	]I_DOG	
_UMYGNJ\	PLX
MHTUP4WXyrq|rmeaaM]XaIMI

\G\\a
cPLX
MHTUPBBPLX
MHTUPDODNOF_PN[NTPVHL[JKLP4WXGQS[a	
DD\SGLHVPLX
MHTUPL[JKLP4444C4XVYGDGOPSN__[S~XWR[N[LSMJ]YVRPQ[a4XVYGDGOPSN__[SXVYGDGOPSN__[SX_RM[FF[XVYGDGOPSN__[S4ZRROW_ZDD~yrq|rmeaaM]Xa_GRUDISIa	cJ]YVRPQ[a4KSPWXP]	_UKNR~yrq|rmeaaM]XaHSO\NMa_Da
cJ]YVRPQ[a4WXyrq|rmeaaM]XaIMI

\G\\a
cKSPWXP]	_UKNRBBKSPWXP]	_UKNRDODNOF_PN[NTPVHE4444QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	D	]I_DOG	4L[JKLP4C4KPM[JKSPWXP]	_UKNR4UYUa\[DKHVK~yrq|rmeaaM]Xa]QU\]aRRa	cyrq|rmeaaM]Xa]FMXaRDGSQacJ]YVRPQ[aRYN[aTSQUDQ
		4444WXUYUa\[DKHVKX_RM[L[JKLP4444WX~yrq|rmeaaM]XaUM_SDP\\\a
cUYUa\[DKHVKPLX
MHTUPyrq|rmeaaM]XaNJ]SSODDIGGaacPLX
MHTUPE4~yrq|rmeaaM]XaYR\Y]GUO[a	cUYUa\[DKHVK4L[JKLP4C4~yrq|rmeaaM]Xa]]MPGGSWaX]TacUYUa\[DKHVKXVYGDGOPSN__[S4WX~yrq|rmeaaM]XaR
[HRNLSDPHa	
cUYUa\[DKHVKJ]YVRPQ[aE4~yrq|rmeaaM]XaYR\Y]GUO[a	cUYUa\[DKHVK4L[JKLP44C44WXZRROW_ZDD~yrq|rmeaaM]XaKHLOSPVW]RWJa	cJ]YVRPQ[aZRROW_ZDD4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~QN]_]V[aWPH_RWZ_J[J]YVRPQ[aJLK[4444WXMV_\MJSFTYWUUIP	M_XOZKJ	YHTJ]YVRPQ[a4WXMV_\MJSFTYBBV[XIVN[_[OTyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD~Z[R[J[aQNJWQPXYTW[WWPHJQ_	4WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cRYN[aTSQUDQ
	G_JOKSMVPR
OHGT\GRMRPPRDV]
YRE444XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cGRMRPPRDV]
YRec_MWRLPYN	GWE4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cWRLPYN	GWSF]
TFJD~yrq|rmeaaM]XaJSJX
DZZNIIJacWRLPYN	GW~yrq|rmeaaM]XaYR\Y]GUO[a	cWRLPYN	GW44C4C4444WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDyrq|rmeaaM]XaVRFQ]YMYDD]a

cRYN[aTSQUDQ
G_JOKSMVPR
OHGT\JDVIV
a_DZE44XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cJDVIV
a_DZec_MW[KRUFE4WXyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_W[KRUF~Z[R[J[aQNJWQPW[KRUF4C4C4C44XKP]JWQPDXUS\NQDOWUIQYGR4E4WXZ[XWP[ZSF]
TFJDL[JKLP4444FQQQJKVLJU	
Z[XWP[Z_UMYGNJ\inskanrkywpazwlina}qpj{pjazwlD	]I_DOG
4PIJ
JQYJQHPUG_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4WX~yrq|rmeaaM]XaS

	ZLD	a
cFQQQJKVLJU	
XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cFQQQJKVLJU	
SF]
TFJD_MYH_OPKN\_O_TPIJ
JQYJQHPUGecYH_OPKN\_O_T4WXZ[XWP[ZIQ[
HR_~yrq|rmeaaM]XaS

	ZLD	a
cinanrkywpazwlXQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cinanrkywpazwlXYTW[WWPHJQ_	_MYH_OPKN\_O_TPIJ
JQYJQHPUGecYH_OPKN\_O_T4C444YaPQ]RNXDJZ[XWP[ZSF]
TFJD

|mnjv4K_YLW\YKYXWKV_ina}qpj{pjazwlSF]
TFJD
yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacYaPQ]RNXDJ_UMYGNJ\`		RYN[aTSQUDQ
yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacYaPQ]RNXDJD	]I_DOG	IQ[
HR_44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacK_YLW\YKYXWKV_PIJ
JQYJQHPUGecK_YLW\YKYXWKV_4XQL[_]VPIJ
JQYJQHPUG_MYH_OPKN\_O_TE4ZRROW_ZDD~yrq|rmeaaM]Xa_GRUDISIa	cYH_OPKN\_O_T44WXZRROW_ZDDBBZRROW_ZDD		
E4IWUSD_]\P~yrq|rmeaaM]XaNDD_U_S]R\\acYH_OPKN\_O_T44WXIWUSD_]\PBBIWUSD_]\P
BBIWUSD_]\P 
		
]QPJWPK[444C4WWXHUUPXXR~yrq|rmeaaM]XaI	WS[XMPacYH_OPKN\_O_T44YaS\KDM~yrq|rmeaaM]XaI	WS[XMPacXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIMI

\G\\a
cWWXHUUPXXRyrq|rmeaaM]XaIMI

\G\\a
cYaS\KDMWWXHUUPXXRYaS\KDM]QPJWPK[4DU[L[YMZaMYFW~yrq|rmeaaM]XaHSO\NMa_Da
cYH_OPKN\_O_TX_RM[PKRR


4T[MKFN_]GPKRR4WXyrq|rmeaaM]XaIMI

\G\\a
cDU[L[YMZaMYFWyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_	
DU[L[YMZaMYFW\VK]DWMHPJT[MKFN_]G\VK]DWMHPJec4[RM[WXaKIGURZU\I_P
SaFYH_OPKN\_O_TFZ
_F[T[MKFN_]GSF]
TFJD4WXT[MKFN_]GPKRRBBH[LMWQPa]QSN_L[T[MKFN_]GRINYW\WDWV_QNR
I	]QPJWPK[4444SRJWD]NY_PWOFFGWURYH]M[YH_OPKN\_O_T4444WXSRJWD]NY_X_RM[E44QWVIDDHOPHQ[VKZMIQ[
HR_D	]I_DOGyrq|rmeaaM]Xa[KDO
YMUaR\VacYH_OPKN\_O_T4]QPJWPK[4C4WXSRJWD]NY_JLK[E4WXWWODUHSXYW_HaYH_OPKN\_O_TYH_OPKN\_O_TIQ[
HR_	E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~QN]_]V[aWPH_RWZ_J[YH_OPKN\_O_TJLK[4C[RM[WXY[D\QVWZZP_YH_OPKN\_O_TMQ\WLYZaV
PWT	KHUZYH_OPKN\_O_TE444IHPXVXNL_VN\MGYaMYH_OPKN\_O_T4[TSM]VFID	aQPDYH_OPKN\_O_T4C4~yrq|rmeaaM]XaYR\Y]GUO[a	cyrq|rmeaaM]Xa]FMXaRDGSQacYH_OPKN\_O_TRYN[aTSQUDQ
yrq|rmeaaM]Xa[KDO
YMUaR\VacYH_OPKN\_O_TSF]
TFJD4]QPJWPK[4C4WXY[D\QVWZZP_YH_OPKN\_O_TMQ\WLYZaV
PWT	KHUZYH_OPKN\_O_TE4IHPXVXNL_VN\MGYaMYH_OPKN\_O_T4[TSM]VFID	aQPDYH_OPKN\_O_T4C4LODXSO\LJYYK	YKVIVPZYH_OPKN\_O_T4C4KW
FXVNDYXM]QQ4MQRG[J[FXNFGIR
ina}qpj{pjazwlD	]I_DOG	4WX~yrq|rmeaaM]XaS

	ZLD	a
cMQRG[J[FXNFGIR
yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cMQRG[J[FXNFGIR
RYN[aTSQUDQ
_MVVT]DILME4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacVVT]DILMBB~yrq|rmeaaM]XaURRZW
ITGa
cVVT]DILM]QPJWPK[4444VSIWPIY\~yrq|rmeaaM]XaNDD_U_S]R\\acVVT]DILM4WXVSIWPIY\BBVSIWPIY\ 	
]QPJWPK[4OQ\J[aHG~yrq|rmeaaM]XaHSO\NMa_Da
cVVT]DILM4WXyrq|rmeaaM]XaIMI

\G\\a
cOQ\J[aHG]QPJWPK[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHGRYN[aTSQUDQ
X_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHGRYN[aTSQUDQ
X_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	cOQ\J[aHGRYN[aTSQUDQ
X_RM[]QPJWPK[4WXXRYXJDM_POQ\J[aHG]QPJWPK[4YYIRYMJPONFMI_ZS\	HVNP_KKOQ\J[aHG444WXyrq|rmeaaM]XaIMI

\G\\a
cYYIRYMJPONFYYIRYMJPONFOQ\J[aHGE4TO[]UPZVQVUTYTVVT]DILMYYIRYMJPONF4444WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~QN]_]V[aWPH_RWZ_J[VVT]DILMJLK[4C4C4C4_Da]D_LX_XTWMT[GZ
ina}qpj{pjazwlD	]I_DOG4_Da]D_LX_XTWMT[GZ
ina}qpj{pjazwl_UMYGNJ\4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_E44aQPYFJN
WLK\P|mnjv_UMYGNJ\`4O\LaU
SPR~Y[JaQNJWQPaQP4WXyrq|rmeaaM]XaIMI

\G\\a
cO\LaU
SPRO\LaU
SPRE4SJaSY
PHPyrq|rmeaaM]Xa]HN[Q	\\KPOVacO\LaU
SPRJLK[4WXyrq|rmeaaM]XaIMI

\G\\a
cSJaSY
PHPYWTIF]KD_PSJaSY
PHP~Z[R[J[aQNJWQPaQP4C4QFWJ	aIGTXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	GUOJ[XOIWQRYN[aTSQUDQ
4WXyrq|rmeaaM]XaIMI

\G\\a
cQFWJ	aIGTXQFWJ	aIGTXyrq|rmeaaM]XaNJ]SSODDIGGaacQFWJ	aIGTX F]FXBByrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\RKHMW]\JKFVQFWJ	aIGTXBBUKR
aLa
VR__FLPQFWJ	aIGTXE4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\SY	]ZUMDJLRRIQ[
HR__UMYGNJ\
4C4C4C4XKP]JWQPDKMOI_PO]XF_
\R]4E4JLGE44WXZ[XWP[ZD	]I_DOG

L[JKLP4WX[SNJGyrq|rme_UMYGNJ\cE4yrq|rme_UMYGNJ\c4QWVIDDHOPHQ[VKZMSF]
TFJDIQ[
HR_4C44WX[SNJGyrq|rmeD	]I_DOGcL[JKLP4yrq|rmeD	]I_DOG
cJLK[4WXWMM[Jay{jeD	]I_DOG
	cyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4HNUHGV	
YDDXO\~Y[JaQNJWQPRYN[aTSQUDQ
_LL_G4ZGPV[M_]X_X_RM[44WXyrq|rmeaaM]Xa]HYHVUa
cHNUHGV	
YDDXO\E4WX[SNJGHNUHGV	
YDDXO\eJcZGPV[M_]X_JLK[4WXZGPV[M_]X_[SNJGHNUHGV	
YDDXO\e_UMYGNJ\cyrq|rmeaaM]Xa]HYHVUa
cHNUHGV	
YDDXO\eSF]
TFJDcE4XQL[_]VHNUHGV	
YDDXO\e_UMYGNJ\c_Ma]WE4WXyrq|rmeaaM]Xa]HYHVUa
ca]W[SNJGa]WeNcE4ZGPV[M_]X_JLK[4\L[_U444C4444C4C44C4WXZGPV[M_]X_yrq|rmeaaM]XaKQTGQ
Na	c_UMYGNJ\
	4C444WX\J

DH]GQG	FQIXTDWYLRT_NPTYMLPL[JKLP4INMNHXTZZGXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_WPJY[JaQNJWQPRYN[aTSQUDQ
	4WXINMNHXTZZGXyrq|rmeaaM]XaD]SGTYaFPQHDac	BBINMNHXTZZGX yrq|rmeaaM]XaD]SGTYaFPQHDacE4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD	~KNZ_J[aQNJWQPXYTW[WWPHJQ_yrq|rmeaaM]XaD]SGTYaFPQHDac4DXUS\NQDOWUIQYGR4C4KPM[JINMNHXTZZGX4\LaVOQQHKFWIPXTDWYLRT_NPTYMLPRINYW\WDWV_QNR
I	4WXHP\aHPIQY]M[E4FVRRPN
U	PaP
4KSKH
FYRM]\XLGaW]K4L[JKLP4C4G
SM	KLTZOJP[HKOPMXO	]LQ4N[	\FIIK]TYUH_LL_G4XTDWYLRT_NPTYMLP444G
SM	KLTZOJP[HXYTW[WWPHJQ_44_SJ	DFNK\\_XZaR]RIUJFKV4XQL[_]V_SJ	DFNK_MQYTZPGS\XVXZE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacQYTZPGS\XVXZN[	\FIIK]TYUHecQYTZPGS\XVXZ4C444HHJaHUZML_LL_G4F\LP	SNOK[UTJVF[HGFKQRY4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacF\LP	SNOecHHJaHUZMLeRYN[aTSQUDQ
F\LP	SNOecc_UMYGNJ\F\LP	SNOec4G[SS_	P~Y[JaQNJWQPSF]
TFJD_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cG[SS_	PG[SS_	P_LL_G4ONO	URQVFWTX_RM[4XQL[_]VN[	\FIIK]TYUH_MNIZPaYMYD_DE4444WVHXDFM\GNLV[~yrq|rmeaaM]XaK_T]FKQRPS[KacNIZPaYMYD_D4444]XKQJY	LVPZYHWVHXDFM\GNLV[WVHXDFM\GNLV[eSF]
TFJDcBWVHXDFM\GNLV[eSF]
TFJDc4WP_FQL][aJKWMM[JG[SS_	PeNIZPaYMYD_DcG[SS_	PeNIZPaYMYD_Dc4WX]XKQJY	LVPZYHWP_FQL][aJK]QPJWPK[44WXyrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOG
WP_FQL][aJKSL
]KPRGWyrq|rmeaaM]Xa[NP\	U	acWP_FQL][aJKyrq|rmeaaM]XaNJ]SSODDIGGaacSL
]KPRGWec]XKQJY	LVPZYHyrq|rmeaaM]XaD]SGTYaFPQHDacWPJSL
]KPRGWec
	]QPJWPK[4ONO	URQVFWTJLK[4\L[_U4C4WXONO	URQVFWTE4XQL[_]VHHJaHUZML_MU[G Da_[D
\ULE4]XKQJY	LVPZYHVQKUXOLNZWIJUPyrq|rmeaaM]Xa[NP\	U	acU[G	Da_[D
\UL4WP_FQL][aJKWMM[JG[SS_	PeU[GcG[SS_	PeU[Gc4WX]XKQJY	LVPZYHWP_FQL][aJK]QPJWPK[4WXyrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJD
WP_FQL][aJKSL
]KPRGWyrq|rmeaaM]Xa[NP\	U	acWP_FQL][aJKyrq|rmeaaM]XaNJ]SSODDIGGaacSL
]KPRGWec]XKQJY	LVPZYHyrq|rmeaaM]XaD]SGTYaFPQHDacWPJSL
]KPRGWec		

	]QPJWPK[4ONO	URQVFWTJLK[4\L[_U4C4C44TPLV]LY\OQyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
4OSVHHMa
_[XG
SM	KLTZOJP[HRYN[aTSQUDQ
TPLV]LY\OQTPLV]LY\OQIQ[
HR_4VJRI[PTQ	LLRXUaZV_DZYG	4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacOSVHHMa
_[XBBWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acOSVHHMa
_[X

ONO	URQVFWTJLK[4WXVJRI[PTQ	L~yrq|rmeaaM]XaJSJX
DZZNIIJacVJRI[PTQ	LONO	URQVFWTJLK[444WXONO	URQVFWTyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\E4RFVJQJ\_RUDKO]TPLV]LY\OQTPLV]LY\OQRYN[aTSQUDQ
4TJXD]UWa\YDK_Y[JaQNJWQPD	]I_DOG	_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cTJXD]UWa\YDK_BByrq|rmeaaM]Xa_LHMQPFPD
Ma
cRFVJQJ\_RUDKO]TJXD]UWa\YDK_JLK[ONO	URQVFWTJLK[4C4WXONO	URQVFWTL[JKLP4KNT[ZIY\yrq|rmeaaM]XaD]SGTYaFPQHDac4YM\LOL	\4JT_SLX_TUDL	\T4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4PK	QHOSW~Y[JaQNJWQP_UMYGNJ\444WXyrq|rmeaaM]XaIMI

\G\\a
cPK	QHOSWyrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOGPK	QHOSW]a
LX[WQY]QWE4YM\LOL	\WPJ]a
LX[WQY]QWec444JT_SLX_TUDL	\TWPJ]a
LX[WQY]QWec4C4444C4PSM[F\RSJT_SLX_TUDL	\TJT_SLX_TUDL	\T
JT_SLX_TUDL	\T				4WXYM\LOL	\ KNT[ZIY\YM\LOL	\PSM[F\RSL[JKLP4444WXZPO_XHQ_]L_ZRYN[aTSQUDQ

L[JKLP4JLGE4YFRORF
PPKTS4VH	]TWI
]WDZG44KSKH
FYRM]\XLGaW]K4RM[_\YODRQDD\Z_VL4VRaYP_SYVU	D4FVRRPN
U	PaP
4PZUa[	RS]U4HH_aKX\ZVJXVL]Y4[Y\\OYJHZYGYTVUNQXN\PVXJ_Pa4[JUDTW[IKSaXI[	[USJ

ZFYOJM4ONSMRONNR[~yrq|rmeaaM]XaJSJX
DZZNIIJacOSVHHMa
_[XBBWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acOSVHHMa
_[X
BBVJRI[PTQ	L~yrq|rmeaaM]XaJSJX
DZZNIIJacVJRI[PTQ	L444WXONSMRONNR[~yrq|rmeaaM]XaJSJX
DZZNIIJacG
SM	KLTZOJP[HSF]
TFJD	ONSMRONNR[JLK[44WXONSMRONNR[yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E44RFVJQJ\_RUDKO]TPLV]LY\OQTPLV]LY\OQ_UMYGNJ\4TJXD]UWa\YDK_Y[JaQNJWQPRYN[aTSQUDQ
	_LL_G4WXyrq|rmeaaM]Xa]HYHVUa
cTJXD]UWa\YDK_BByrq|rmeaaM]Xa_LHMQPFPD
Ma
cRFVJQJ\_RUDKO]TJXD]UWa\YDK_JLK[ONSMRONNR[JLK[4C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~KNZ_J[aQNJWQPSF]
TFJDKNT[ZIY\BONSMRONNR[JT_SLX_TUDL	\TXYTW[WWPHJQ_
4X[TZUPFPFHI_LL_G4XQL[_]VN[	\FIIK]TYUH_MNIZPaYMYD_DE4[	UNRRZKS	NIZPaYMYD_DG
SM	KLTZOJP[HXYTW[WWPHJQ_	[Y\\OYJHZYGBByrq|rmeaaM]Xa[NP\	U	acNIZPaYMYD_DF_F
SF]
TFJD[JUDTW[IKSaX4WVHXDFM\GNLV[~yrq|rmeaaM]XaK_T]FKQRPS[KacNIZPaYMYD_D4WXWVHXDFM\GNLV[E4X[TZUPFPFHIeNIZPaYMYD_DcWVHXDFM\GNLV[eD	]I_DOGcBWVHXDFM\GNLV[e_UMYGNJ\c[	UNRRZKS	D	]I_DOGyrq|rmeaaM]XaD]SGTYaFPQHDac4C4C4XQL[_]VHHJaHUZML_MU[G Da_[D
\ULE4Z\\ND_TP
VQKUXOLNZWIJUPyrq|rmeaaM]Xa[NP\	U	acU[G
Da_[D
\UL4WXZ\\ND_TP
BByrq|rmeaaM]Xa[NP\	U	acZ\\ND_TP
_UMYGNJ\Z\\ND_TP
IQ[
HR_yrq|rmeaaM]XaD]SGTYaFPQHDac4X[TZUPFPFHIeU[GcZ\\ND_TP
444C4~KNZ_J[aQNJWQP_UMYGNJ\X[TZUPFPFHISF]
TFJD
444CXWP_RRGE4FT_Q_YTVaGTRYN[aTSQUDQ

4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE44QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C444XKP]JWQPVQKUXOLNZWIJUPNIZPaYMYD_DDa_[D
\UL4E444WVHXDFM\GNLV[~yrq|rmeaaM]XaK_T]FKQRPS[KacNIZPaYMYD_D4WXWVHXDFM\GNLV[L[JKLP4]XKQJY	LVPZYHWVHXDFM\GNLV[eD	]I_DOGcBWVHXDFM\GNLV[e_UMYGNJ\c4WXWVHXDFM\GNLV[eXYTW[WWPHJQ_c 	
	L[JKLP_UMYGNJ\
]XKQJY	LVPZYH444DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D4L[JKLP]XKQJY	LVPZYHByrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHDa_[D
\ULX_RM[444C4XKP]JWQPYJVMORWH\HN
G4E4aNHyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\Y[JaQNJWQP_UMYGNJ\	4a	DYH\TI4IHYHGRUH	Gyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGY[JaQNJWQPSF]
TFJD	4WXIHYHGRUH	GaNHE4YRQ\_RINZ\4WXyrq|rmeaaM]XaJFVY[	SJPKa	cINZ\yrq|rmeaaM]Xa__VX_]O[acINZ\D	]I_DOG	yrq|rmeaaM]XaIMI

\G\\a
caNHaNHWMM[JINZ\ QNJWQPME44~INZ\ OK[LGINZ\ NL[N_L[zbF
r{bF
bF
xlqsEINZ\ QNJWQPMCivbF
l{bFXbF	JWQPabF[_S[M]abF	[bF[ZWPYaWbF[HbFRbFZbFJ[pbF

QNJbFQPaH_RK[bF	aNH4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
	E4~INa]_]V[aZ[R[J[SF]
TFJD_UMYGNJ\4~INa]_]V[aZ[R[J[_UMYGNJ\SF]
TFJD4444C4C[RM[E44~Z[R[J[aQNJWQPSF]
TFJD4C4C444C4XKP]JWQPa	DYH\TI4E4JLGE4WXZ[XWP[ZIQ[
HR_

L[JKLP4G
SM	KLTZOJP[HKOPMXO	]LQ4F
VNOXGDX\]MGUOK\T\L]4RNDT\KHO_LYFJN
WLK\P|mnjvSF]
TFJD
	`XYTW[WWPHJQ_4GLQUQN_H_LYFJN
WLK\P|mnjvSF]
TFJD
`XYTW[WWPHJQ_4]VFKSS]V]KRSYFJN
WLK\P|mnjvRYN[aTSQUDQ
F
F
RYN[aTSQUDQ
4\OGI	JJMR[JYFJN
WLK\P|mnjvRYN[aTSQUDQ
		XYTW[WWPHJQ_4QYMW[PG
J[YFJN
WLK\P|mnjvSF]
TFJD
	IQ[
HR_4GHR[L_HVOLRYN[aTSQUDQ
YFJN
WLK\P|mnjvY`4DZWXI	O_Z\KIZ_LL_G4G
SM	KLTZOJP[HXYTW[WWPHJQ_ _UMYGNJ\	4G
SM	KLTZOJP[HXYTW[WWPHJQ_
 SF]
TFJD	444XQL[_]VDZWXI	O_Z\KIZ_MNIZPaYMYD_D NL[XWFE44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNIZPaYMYD_D]QPJWPK[4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cNIZPaYMYD_D44WXDODNOF_PN[NTPVHX_RM[]QPJWPK[444Y	FP
RUVLRYN[aTSQUDQ
	NL[XWFRYN[aTSQUDQ
	NL[XWFSF]
TFJD		4ZGJT\OJ_F
W[yrq|rmeaaM]Xa]H[KYS
JDPXa
cY	FP
RUVLDODNOF_PN[NTPVH4WXZGJT\OJ_F
W[DODNOF_PN[NTPVHTO[]UPZVQVUTYTNIZPaYMYD_DZGJT\OJ_F
W[4C4VXUI[UK[DG
SM	KLTZOJP[HSF]
TFJD4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacVXUI[UK[DE4YUTO	TRN~yrq|rmeaaM]XaHSO\NMa_Da
cVXUI[UK[D4WXyrq|rmeaaM]XaIMI

\G\\a
cYUTO	TRNYUTO	TRNE4444WXyrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJDyrq|rmeaaM]Xa[NP\	U	acYUTO	TRN
BByrq|rmeaaM]Xa_K_QN_\W	a]a	cYUTO	TRNIQ[
HR_E4444Y_HVRRKFFH]X
]VL
RVXUI[UK[DF_F
_4_I	Q]G
P
VXUI[UK[D4C[RM[E4Q_NT]_MLH]yrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
	YUTO	TRN4WXyrq|rmeaaM]XaIMI

\G\\a
cQ_NT]_MLH]Q_NT]_MLH]YUTO	TRNTO[]UPZVQVUTYTVXUI[UK[DQ_NT]_MLH]4KPM[JQ_NT]_MLH]4C4C4KPM[JYUTO	TRN44C4O	LG_NaIWDyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPD	]I_DOG4WO[NLUFU\SXGQZ[XWP[ZRYN[aTSQUDQ
ina}qpj{pjazwlIQ[
HR_O	LG_NaIWD4PORUXFG_G
I_LL_G4G
SM	KLTZOJP[HRNDT\KHO_L4444G
SM	KLTZOJP[HGLQUQN_H_L4G
SM	KLTZOJP[H]VFKSS]V]KRS4F
VNOXGDX\]\OGI	JJMR[J4F
VNOXGDX\]QYMW[PG
J[4F
VNOXGDX\]GLQUQN_H_L4F
VNOXGDX\]]VFKSS]V]KRS4O	LG_NaIWD\OGI	JJMR[J444O	LG_NaIWDQYMW[PG
J[4O	LG_NaIWDGLQUQN_H_L4O	LG_NaIWD]VFKSS]V]KRS4WO[NLUFU\SXGQ\OGI	JJMR[J4WO[NLUFU\SXGQQYMW[PG
J[4WO[NLUFU\SXGQGLQUQN_H_L4WO[NLUFU\SXGQ]VFKSS]V]KRS44]
\DIYL
DK[UTJVF[HGFKQRY4PORUXFG_G
Iec]
\DIYL
Dec4PORUXFG_G
Iec]
\DIYL
Dec_UMYGNJ\
44KPM[J]
\DIYL
D4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cG
SM	KLTZOJP[HIQ[
HR_RNDT\KHO_L_M\LDPN[N
]UPORUXFG_G
Iec\LDPN[N
]U44XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cG
SM	KLTZOJP[H_UMYGNJ\RNDT\KHO_L_M\LDPN[N
]UPORUXFG_G
Iec\LDPN[N
]U4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	c|mnjvIQ[
HR_GHR[L_HVOLXYTW[WWPHJQ__MQaIW
KaPORUXFG_G
IecQaIW
Ka4444XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cG
SM	KLTZOJP[HGHR[L_HVOLD	]I_DOG_MQaIW
KaPORUXFG_G
IecQaIW
Ka44XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cF
VNOXGDX\]GHR[L_HVOLXYTW[WWPHJQ_
_MQaIW
KaPORUXFG_G
IecQaIW
Ka44XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cO	LG_NaIWDGHR[L_HVOLD	]I_DOG
_MQaIW
KaPORUXFG_G
IecQaIW
Ka44XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	cWO[NLUFU\SXGQGHR[L_HVOLIQ[
HR_
_MQaIW
KaPORUXFG_G
IecQaIW
Ka4C4IJDaQXYFJN
WLK\P|mnjvYFF44Q_RX
RXSY_LL_G|mnjvRYN[aTSQUDQ

G
SM	KLTZOJP[HF
VNOXGDX\]O	LG_NaIWDWO[NLUFU\SXGQ4XQL[_]VQ_RX
RXSY_MaYZE4WX~yrq|rmeaaM]XaS

	ZLD	a
caYZ~yrq|rmeaaM]XaURRZW
ITGa
caYZU
]TV\
IZDSUaYZIQ[
HR_IJDaQXRINYW\WDWV_QNR
I	SF]
TFJD
4C4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4XQL[_]VQ_RX
RXSY_MaYZE4XQL[_]V_LL_GXYTW[WWPHJQ_
SF]
TFJD
RYN[aTSQUDQ


D	]I_DOG
SF]
TFJD
IQ[
HR_
	RYN[aTSQUDQ

RYN[aTSQUDQ

IQ[
HR__MMUZOJ
GJFGZUE4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	caYZMUZOJ
GJFGZU_MX\KDH]YPHPORUXFG_G
IecX\KDH]YPH4C4XQL[_]V_LL_G~yrq|rmeaaM]Xa\TOUSOOMFG\a	caYZIQ[
HR__MD\HPHDKXHOFPORUXFG_G
IecD\HPHDKXHOF4C444C4KPM[JIJDaQXQ_RX
RXSYaYZMUZOJ
GJFGZUX\KDH]YPHD\HPHDKXHOF44444F]N[_H[[XYTID\N_LL_Gyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HXYTW[WWPHJQ_yrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP_UMYGNJ\yrq|rmeaaM]XaNGLV\SLPGacF
VNOXGDX\]IQ[
HR_yrq|rmeaaM]XaNGLV\SLPGacO	LG_NaIWDD	]I_DOGyrq|rmeaaM]XaNGLV\SLPGacWO[NLUFU\SXGQXYTW[WWPHJQ_4WXZ[XWP[ZRYN[aTSQUDQ

F]N[_H[[XYTID\Necyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlD	]I_DOG4VIIQVPKaVGS_LL_G4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cF]N[_H[[XYTID\N_MaNZE4VIIQVPKaVGSecaNZGLQUQN_H_L4VIIQVPKaVGSecaNZ]VFKSS]V]KRS4VIIQVPKaVGSecaNZRYN[aTSQUDQ
]VFKSS]V]KRS4C4KPM[JF]N[_H[[XYTID\NaNZ4XQL[_]VVIIQVPKaVGS_MNHY	\_OaTE44WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNHY	\_OaT[DNLN	F]PaLJJFRLKNHY	\_OaTPKRR4C4KPM[JNHY	\_OaT4UZ[]YPT\_LL_Gyrq|rmeaaM]XaNGLV\SLPGac|mnjvXYTW[WWPHJQ_4WXZ[XWP[ZXYTW[WWPHJQ_
UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlXYTW[WWPHJQ_	44UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HD	]I_DOG	44UZ[]YPT\ecyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4POKYZTRIWHG\]_LL_G4XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cUZ[]YPT\_MKK\XLGL_\POKYZTRIWHG\]ecKK\XLGL_\D	]I_DOG4444KPM[JUZ[]YPT\KK\XLGL_\4XQL[_]VPOKYZTRIWHG\]_MNPUWKRPaZE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacNPUWKRPaZ]QPJWPK[4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cNPUWKRPaZ4WXDODNOF_PN[NTPVHyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHXYTW[WWPHJQ_X_RM[E4DODNOF_PN[NTPVHyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_yrq|rmeaaM]XaLYIZQQ_TacGLQUQN_H_L_UMYGNJ\bPDODNOF_PN[NTPVH4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHE4DODNOF_PN[NTPVHyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_
yrq|rmeaaM]XaLYIZQQ_TacGLQUQN_H_LSF]
TFJDbPDODNOF_PN[NTPVH44C4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHE4DODNOF_PN[NTPVHyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\yrq|rmeaaM]XaLYIZQQ_TacGLQUQN_H_LSF]
TFJD	bPDODNOF_PN[NTPVH4C4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHTO[]UPZVQVUTYTNPUWKRPaZDODNOF_PN[NTPVH4C4C4444XFOGZD
RTZDZSUU|mnjv_UMYGNJ\444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXFOGZD
RTZDZSUUE4VLY]IK
GQ	IJ
yrq|rmeaaM]Xa]FMXaRDGSQac|mnjvXYTW[WWPHJQ_
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacVLY]IK
GQ	IJ
XFOGZD
RTZDZSUUVLY]IK
GQ	IJ
4C4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacXFOGZD
RTZDZSUU~yrq|rmeaaM]XaURRZW
ITGa
cXFOGZD
RTZDZSUUE4aI]~yrq|rmeaaM]XaHSO\NMa_Da
cXFOGZD
RTZDZSUU4WXyrq|rmeaaM]XaIMI

\G\\a
caI]yrq|rmeaaM]Xa_K_QN_\W	a]a	caI]_UMYGNJ\X_RM[E4ODUD]

U_[
yrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_Z[XWP[ina}}v{JLK[bPaI]444WXyrq|rmeaaM]XaIMI

\G\\a
cODUD]

U_[
ODUD]

U_[
aI]GQS[a	
DD\SGLHVODUD]

U_[
E4aKPDLaGL
NY~yrq|rmeaaM]Xa_GRUDISIa	cXFOGZD
RTZDZSUU4WXTO[]UPZVQVUTYTXFOGZD
RTZDZSUUODUD]

U_[
E4WXaKPDLaGL
NY~yrq|rmeaaM]XaKHLOSPVW]RWJa	cXFOGZD
RTZDZSUUaKPDLaGL
NY4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
~Z[R[J[aQNJWQPXYTW[WWPHJQ_	4C4C4KPM[JODUD]

U_[
aKPDLaGL
NY4C4KPM[JaI]4444C4KPM[JXFOGZD
RTZDZSUUVLY]IK
GQ	IJ
4QSLNKNXWF]yrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
~yrq|rmeaaM]Xa[PD\GWFacSF]
TFJDX_RM[4WXQSLNKNXWF]BBQSLNKNXWF]QSLNKNXWF]D	]I_DOG4\OPV[Na_Pa_LL_Gyrq|rmeaaM]XaNGLV\SLPGac|mnjvD	]I_DOG4WXZ[XWP[Z_UMYGNJ\
\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacina}qpj{pjazwlXYTW[WWPHJQ_4\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacG
SM	KLTZOJP[HRYN[aTSQUDQ
4\OPV[Na_Paecyrq|rmeaaM]XaNGLV\SLPGacyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_4RSDMMTTKVY	WZQ__LL_G44XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
c\OPV[Na_Pa_MGVRaJQOT	KPRSDMMTTKVY	WZQ_ecGVRaJQOT	KPQSLNKNXWF]44KPM[J\OPV[Na_PaGVRaJQOT	KP4XQL[_]VRSDMMTTKVY	WZQ__MTTLNXW\I_\]VE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacTTLNXW\I_\]V]QPJWPK[444DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
cTTLNXW\I_\]V4WXDODNOF_PN[NTPVHyrq|rmeaaM]Xa_K_QN_\W	a]a	cDODNOF_PN[NTPVHRYN[aTSQUDQ
X_RM[E4DODNOF_PN[NTPVHyrq|rmeaaM]Xa]H[KYS
JDPXa
c_UMYGNJ\yrq|rmeaaM]XaLYIZQQ_Tac]VFKSS]V]KRSSF]
TFJD	DODNOF_PN[NTPVH4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHTO[]UPZVQVUTYTTTLNXW\I_\]VDODNOF_PN[NTPVH44C4C4YJIaK]yrq|rmeaaM]XaaVYPVSS
acPORUXFG_G
IVIIQVPKaVGS4D
V\P	KTS_LL_G4R]\XRQ	I]aHX_RM[4XQL[_]Vyrq|rmeaaM]XaZOVZW
]WRZLLKa	cPOKYZTRIWHG\]RSDMMTTKVY	WZQ__MQHP\	IVLNMLE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacQHP\	IVLNML]QPJWPK[444U	LW\JV~yrq|rmeaaM]XaHSO\NMa_Da
cQHP\	IVLNML4WXyrq|rmeaaM]XaIMI

\G\\a
cU	LW\JVE4R]\XRQ	I]aHJLK[4]QPJWPK[4C4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cU	LW\JV_UMYGNJ\X_RM[]QPJWPK[44WXyrq|rmeaaM]XaVRFQ]YMYDD]a

cSF]
TFJDU	LW\JVSL
]KPRGWE444XQL[_]Vyrq|rmeaaM]XaZOVZW
]WRZLLKa	cSL
]KPRGWecSL
]KPRGWecSL
]KPRGWec_MWWXHUUPXXRE4WXWWXHUUPXXRD
V\P	KTSeyrq|rmeaaM]Xa[KDO
YMUaR\VacWWXHUUPXXRcJLK[4444C4C4KPM[JU	LW\JVSL
]KPRGWWWXHUUPXXR4C4WXR]\XRQ	I]aHE4XQL[_]VYJIaK]_MJ]YVRPQ[aE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]YVRPQ[aE444WXWMM[JD
V\P	KTSeyrq|rmeaaM]Xa[KDO
YMUaR\VacJ]YVRPQ[ac]QPJWPK[44Y_HVRRKFFH]X
]VL
RJ]YVRPQ[a4_I	Q]G
P
J]YVRPQ[a4C4C4C4KPM[JD
V\P	KTSR]\XRQ	I]aHQHP\	IVLNML4XQL[_]V\\_XZaR]RIUJFKV_M\J[\T
FWDK		WM]TE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJac\J[\T
FWDK		WM]TBB~yrq|rmeaaM]XaURRZW
ITGa
c\J[\T
FWDK		WM]T]QPJWPK[4DODNOF_PN[NTPVH~yrq|rmeaaM]XaHSO\NMa_Da
c\J[\T
FWDK		WM]T4WXyrq|rmeaaM]XaIMI

\G\\a
cDODNOF_PN[NTPVHE44NIUYY[]YX_OQHNJOXU

GHKPDODNOF_PN[NTPVHD	]I_DOGD	]I_DOG
44NIUYY[]YX_OQHNJOXU

GHKPNIUYY[]YX_IQ[
HR_
D	]I_DOG
4WXyrq|rmeaaM]XaIMI

\G\\a
cNIUYY[]YX_NIUYY[]YX_DODNOF_PN[NTPVHTO[]UPZVQVUTYT\J[\T
FWDK		WM]TNIUYY[]YX_4KPM[JNIUYY[]YX_44C4C4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	
yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4U[GQWMZ
HN]OGMKVDOXa	4WXU[GX_RM[E4IDH]GQ~yrq|rmeaaM]XaPP_MVXQR[a	
cU[GI4444WXIDH]GQE4~yrq|rmeaaM]XaJZ_MYLKaLa	cIDH]GQ4~yrq|rmeaaM]Xa_NQ
LUMaaOVacIDH]GQ4C4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
E4YKYRaNa

UYFJN
WLK\P|mnjvSF]
TFJD4~Z[R[J[aQNJWQPYKYRaNa

U4HNUHGV	
YDDXO\yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~Y[JaQNJWQPSF]
TFJD_LL_G_LL_G444WXyrq|rmeaaM]Xa]HYHVUa
cHNUHGV	
YDDXO\E4WXWMM[JHNUHGV	
YDDXO\e\c_I	Q]G
P
HNUHGV	
YDDXO\e\c4WXWMM[JHNUHGV	
YDDXO\e_UMYGNJ\cyrq|rmeaaM]Xa]HYHVUa
cHNUHGV	
YDDXO\eSF]
TFJD	cE444XQL[_]VHNUHGV	
YDDXO\e_UMYGNJ\	c_Ma]WE4WXyrq|rmeaaM]Xa]HYHVUa
ca]WWMM[Ja]We\c_I	Q]G
P
a]We\c444C4C4C4~Z[R[J[aQNJWQPD	]I_DOG4~Z[R[J[aQNJWQPRYN[aTSQUDQ
4~Z[R[J[aQNJWQPXYTW[WWPHJQ_4~Z[R[J[aQNJWQPRYN[aTSQUDQ
	4~Z[R[J[aQNJWQPSF]
TFJD	4~Z[R[J[aQNJWQPRYN[aTSQUDQ
	
44~Z[R[J[aQNJWQPD	]I_DOG4~Z[R[J[aQNJWQPD	]I_DOG4KPM[JHNUHGV	
YDDXO\a]W4C4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4~Z[R[J[aJL_PMW[PJ_UMYGNJ\4~Z[R[J[aJL_PMW[PJD	]I_DOG4~Z[R[J[aJL_PMW[PJNZKPMO\X[I[U44C4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
E4~INa]R[_LaM]V[ZKR[ZaVQQUIQ[
HR_	4444~INa]R[_LaM]V[ZKR[ZaVQQUSF]
TFJD	4~INa]R[_LaM]V[ZKR[ZaVQQUSWHLLXDFJUGMKT4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
		Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C444C4XKP]JWQPYTVUNQXN\PVXJ_Pa4E44JLGE4WXZ[XWP[ZRYN[aTSQUDQ


L[JKLPX_RM[4G
SM	KLTZOJP[HKOPMXO	]LQ4ZSF[DX	KTDHG
SM	KLTZOJP[HSF]
TFJD	4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPD	]I_DOG4XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW	BByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW 
BBRKHMW]\JKFVXaQDFYTWBBGQS[a	
DD\SGLHVXaQDFYTWL[JKLPX_RM[4444]KLL[PJ~yrq|rmeaaM]XaVWRNOHYa]Oa	cZSF[DX	KTDH~yrq|rmeaaM]XaHSO\NMa_Da
cZSF[DX	KTDH4WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZM_UMYGNJ\	IQ[
HR_4L[JKLPX_RM[4C4444]KLL[PJT_DLVDPGFPFPaDQRK]KLL[PJ4DX_
ZZZ	OLRORINYW\WDWV_QNR
I	YFJN
WLK\P|mnjvIQ[
HR_4G
GDOHVVHPLXXYTW[WWPHJQ_DX_
ZZZ	OLROXYTW[WWPHJQ_
4GLaSFK[\]aDaXYTW[WWPHJQ_DX_
ZZZ	OLROSF]
TFJD
4IPFV[O	THLZH_YFJN
WLK\P|mnjvIQ[
HR_F
F
4MJDMWF\_	YW]]yrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
IPFV[O	THLZH_RYN[aTSQUDQ

]KLL[PJ4ITaMNOyrq|rmeaaM]Xa_K_QN_\W	a]a	cMJDMWF\_	YW]]XYTW[WWPHJQ_X_RM[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJG
GDOHVVHPLXX_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJGLaSFK[\]aDaX_RM[ITaMNOL[JKLPJLK[4]KLL[PJyrq|rmeaaM]Xa]H[KYS
JDPXa
cIQ[
HR_MJDMWF\_	YW]]4444WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZMSF]
TFJD	SF]
TFJD44L[JKLPX_RM[4C4HPTMOHYaaVNT]_TSGKYNR	aUMM4WXHPTMOHYaaVNTL[JKLPX_RM[4V]RLTZYORYN[aTSQUDQ
	yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacaGPQ]VFQS_QMJLWPYTJ_	QLHU	YJSMDSOF
4SG
HOY
KD_U	LM	JI
YGTaRGYG[X4_UMYGNJ\
4_LL_Gaamrkyaaaanrkywpa|m{
aaaayklzaps{aaaah{lmwqpaa4_LL_GaGPQ]VFQS_QHPTMOHYaaVNTV]RLTZYORINYW\WDWV_QNR
I	4444WXSG
HOY
KD_U	E4WXWPJY[JaQNJWQPSF]
TFJD	 QWVIDDHOPHQ[VKZMIQ[
HR_	_UMYGNJ\4L[JKLPX_RM[44C4]KLL[PJT_DLVDPGFPFPaDQRK]KLL[PJ4JMM[VY	X_PVSJyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJD
SG
HOY
KD_U	4MM
QONQF
aDyrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJ4WXMM
QONQF
aDE4WXOYRGP[M
J]UHJF]Ra
IQ[
HR_	E4QWVIDDHOPHQ[VKZMSF]
TFJDSF]
TFJD4L[JKLPX_RM[4C4WXGXLa_NLOL_PZSF[DX	KTDH]KLL[PJE4QWVIDDHOPHQ[VKZM_UMYGNJ\_UMYGNJ\4L[JKLPX_RM[4C4HDZZFLJaIRTM\QSLDPNRYN[aTSQUDQ
4C[RM[E4WXGXLa_NLOL_PZSF[DX	KTDHE444QWVIDDHOPHQ[VKZMD	]I_DOGRYN[aTSQUDQ
44L[JKLPX_RM[4C444C4KRVZ_GODDVYaHGZ[[LY_
]KLL[PJG
GDOHVVHPLXbPJMM[VY	X_PVSJbPGLaSFK[\]aDa4WXTO[]UPZVQVUTYTZSF[DX	KTDHKRVZ_GODDVE4L[JKLPX_RM[4C4WUUIP	M_XOZKJ	YHTZSF[DX	KTDH444Xa\
Qa\
N_TUZSF[DX	KTDH444L[JKLPJLK[4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJDQ	MNQOPFD4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4444L[JKLPX_RM[444C4444C4XKP]JWQP\\_XZaR]RIUJFKV4E4VGaX
KNKaFQY_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\L[JKLPVGaX
KNKaFQY4DDTORYQH[[FN]PZ[XWP[ZRYN[aTSQUDQ

ina}qpj{pjazwlZ[XWP[ZXYTW[WWPHJQ_

|mnjvSF]
TFJDD	]I_DOG
444VQU]\PKPM]KaMJLWPY~Y[JaQNJWQPIQ[
HR_4WXVQU]\PKPM]KaVGaX
KNKaFQYecDDTORYQH[[FN]PVQU]\PKPM]KaXYTW[WWPHJQ_44Q]IXIXV_
MJLWPY~Y[JaQNJWQPD	]I_DOG4WXQ]IXIXV_
Q]IXIXV_
VQU]\PKPM]KaVGaX
KNKaFQYecDDTORYQH[[FN]PQ]IXIXV_
SF]
TFJD	4L[JKLPVGaX
KNKaFQY4C4444XKP]JWQPV\GDZ
NWINODTGZDV4E444WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
WMaSKRJWMWJ[yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4L[JKLP_LL_G~Y[JaMWJ[aQNJWQP_UMYGNJ\_LL_G44C4L[JKLP_LL_G~Y[JaQNJWQP_UMYGNJ\_LL_G4C4XKP]JWQPJVNIJDMVaPWXVG]\TK[\IIOSJ4E4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	WMaSKRJWMWJ[yrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\	E4444~KNZ_J[aMWJ[aQNJWQPSF]
TFJD	K[\IIOSJ4L[JKLP4C4~KNZ_J[aQNJWQPXYTW[WWPHJQ_	K[\IIOSJD	]I_DOG	4C4XKP]JWQP\FKLS[W	P\QJa_INIZPaYMYD_D44E4K[\IIOSJV\GDZ
NWINODTGZDV4L[JKLPWMM[JK[\IIOSJeYFJN
WLK\PNIZPaYMYD_D
c4C44XKP]JWQPNP\Y\[MFWRNVYKNIZPaYMYD_D4E4K[\IIOSJV\GDZ
NWINODTGZDV4444FIJVJGMJNMPyrq|rmeaaM]XaD]SGTYaFPQHDacF]Z[F][]4XQL[_]VK[\IIOSJ_M]N]L	LM	M MFFWQVHQVE44WXWPJMFFWQVHQVFIJVJGMJNMPKPM[JK[\IIOSJe]N]L	LM	Mc44C4K[\IIOSJeYFJN
WLK\PNIZPaYMYD_D
cyrq|rmeaaM]XaD]SGTYaFPQHDac4JVNIJDMVaPWXVG]\TK[\IIOSJ4C4XKP]JWQPRQ_ZVZZHXD]HUaTXP_NIZPaYMYD_DKRVZ_GODDV4E4WXyrq|rmeaaM]XaIMI

\G\\a
cKRVZ_GODDVBBKRVZ_GODDVBByrq|rmeaaM]XaNJ]SSODDIGGaacKRVZ_GODDV 

L[JKLP4HVMW	MYHO	yrq|rmeaaM]XaHMU
XNXMKa		cIQ[
HR_	KRVZ_GODDV4SFNYKJ]ND_LL_G~Y[JaQNJWQPSF]
TFJD	
_LL_G4I	ZLWVK_IYFJN
WLK\PNIZPaYMYD_D4WXWMM[JSFNYKJ]NDeI	ZLWVK_IceIQ[
HR_	cSFNYKJ]NDeI	ZLWVK_IceRYN[aTSQUDQ
	cHVMW	MYHO	L[JKLP4SFNYKJ]NDeI	ZLWVK_Ic_LL_G_UMYGNJ\ yrq|rmeaaM]XaNJ]SSODDIGGaacKRVZ_GODDVIQ[
HR_	 HVMW	MYHO	SF]
TFJD	 yrq|rmeaaM]Xa\	V]W	QFacKRVZ_GODDV4~KNZ_J[aQNJWQPSF]
TFJD	
SFNYKJ]ND_UMYGNJ\	4C4XKP]JWQP]FV
HDFFSKJG_JaYNIZPaYMYD_D4E4SFNYKJ]ND_LL_G~Y[JaQNJWQPSF]
TFJD		_LL_G4Q	MNQOPFDWMM[JSFNYKJ]NDeYFJN
WLK\PNIZPaYMYD_DcSFNYKJ]NDeYFJN
WLK\PNIZPaYMYD_D	`cPKRR4WXyrq|rmeaaM]Xa]HYHVUa
cQ	MNQOPFDBB[SNJGQ	MNQOPFDeSF]
TFJD	cBB[SNJGQ	MNQOPFDeXYTW[WWPHJQ_	cBB[SNJGQ	MNQOPFDeSF]
TFJD	cL[JKLPX_RM[44TLRJLFQGaU[Tyrq|rmeaaM]Xa]HN[Q	\\KPOVacQ	MNQOPFDeSF]
TFJD	cJLK[4WXyrq|rmeaaM]XaIMI

\G\\a
cTLRJLFQGaU[TBByrq|rmeaaM]XaNJ]SSODDIGGaacTLRJLFQGaU[TWPJQ	MNQOPFDeIQ[
HR_	cL[JKLPX_RM[4WXyrq|rmeaaM]XaHMU
XNXMKa		cXYTW[WWPHJQ_	TLRJLFQGaU[TQ	MNQOPFDe_UMYGNJ\	cL[JKLPX_RM[4WXGQS[a	
DD\SGLHVTLRJLFQGaU[TL[JKLPX_RM[4L[JKLPTLRJLFQGaU[T4C4XKP]JWQP]M_SZD[ODDJ\J[\T
FWDK		WM]T]KLL[PJ4E4VHLGKNHaU	Y[MI_ZS\	HVNP_KK]KLL[PJ4444WXyrq|rmeaaM]XaIMI

\G\\a
cVHLGKNHaU	Y[BBVHLGKNHaU	Y[L[JKLPX_RM[444JPZHHHFaIXZ
MMGUOK\T\L]D	]I_DOG	YFJN
WLK\P\J[\T
FWDK		WM]TSF]
TFJD	44a[F~yrq|rmeaaM]XaJSJX
DZZNIIJacJPZHHHFaIXZ
M~yrq|rmeaaM]XaHSO\NMa_Da
cJPZHHHFaIXZ
MX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
ca[FBBa[FVHLGKNHaU	Y[E4WXTO[]UPZVQVUTYTJPZHHHFaIXZ
MVHLGKNHaU	Y[L[JKLPX_RM[4a[F~yrq|rmeaaM]XaJSJX
DZZNIIJacJPZHHHFaIXZ
M~yrq|rmeaaM]XaHSO\NMa_Da
cJPZHHHFaIXZ
MX_RM[4444WXyrq|rmeaaM]XaIMI

\G\\a
ca[FBBa[FVHLGKNHaU	Y[L[JKLPX_RM[4C4RQ_ZVZZHXD]HUaTXP_\J[\T
FWDK		WM]TVHLGKNHaU	Y[4L[JKLPJLK[4C4XKP]JWQPXTWZPUaWa
4E4JVNIJDMVaPWXVG]\T_LL_G4444C4XKP]JWQPNF]XTVJVDIDVQOV4E4JLGE4WXZ[XWP[ZSF]
TFJD

BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_L[JKLP44XQL[_]V\\_XZaR]RIUJFKV_MHNDGKQFKKE4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJacHNDGKQFKK~yrq|rmeaaM]XaNDD_U_S]R\\acHNDGKQFKK ]QPJWPK[4JPZHHHFaIXZ
MMGUOK\T\L]IQ[
HR_	YFJN
WLK\PHNDGKQFKK`IQ[
HR_	4SFNaU		TLT~yrq|rmeaaM]XaJSJX
DZZNIIJacJPZHHHFaIXZ
M~yrq|rmeaaM]XaHSO\NMa_Da
cJPZHHHFaIXZ
MX_RM[4WXyrq|rmeaaM]XaIMI

\G\\a
cSFNaU		TLTBBSFNaU		TLTE4SFNaU		TLT]FV
HDFFSKJG_JaYHNDGKQFKK4WXyrq|rmeaaM]XaIMI

\G\\a
cSFNaU		TLTSFNaU		TLT~TO[]UPZVQVUTYTJPZHHHFaIXZ
MSFNaU		TLT44C4WXyrq|rmeaaM]XaIMI

\G\\a
cSFNaU		TLTBBSFNaU		TLT]QPJWPK[4]R[_LMJ_J]_]V[JLK[HNDGKQFKK4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacHNDGKQFKK~yrq|rmeaaM]XaNDD_U_S]R\\acHNDGKQFKK ]QPJWPK[4WXTO[]UPZVQVUTYTHNDGKQFKKSFNaU		TLTE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_
IQ[
HR_	4444NP\Y\[MFWRNVYKHNDGKQFKK4C44C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ

Q	MNQOPFD4444C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPI[	[USJ

ZFYOJM4E44JLGE4WXZ[XWP[ZIQ[
HR_	L[JKLPX_RM[4YHT\RVQSY	\\_XZaR]RIUJFKV4WX[SNJGYHT\RVQSY	L[JKLPX_RM[4DX_
ZZZ	OLRORINYW\WDWV_QNR
I	YFJN
WLK\P|mnjvSF]
TFJD
`4G
GDOHVVHPLXIQ[
HR_	DX_
ZZZ	OLROSF]
TFJD
4GLaSFK[\]aDa_UMYGNJ\	
DX_
ZZZ	OLROSF]
TFJD
4444V]RLTZYOSF]
TFJD	yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac|mnjvMJLWPYTJ_	QLHU	YJSMDSOFFF	4444aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPSF]
TFJD	4HPTMOHYaaVNT]_TSGKYNR	aUMM4WXHPTMOHYaaVNTL[JKLPX_RM[4444FQF\KLPITOaJLM	JI
YGTaRGYG[X444IQ[
HR_		4_LL_Gaamrkyaaaanrkywpa|m{
aaaayklzaps{aaaah{lmwqpaa4444_LL_GaGPQ]VFQS_QHPTMOHYaaVNTV]RLTZYORINYW\WDWV_QNR
I	44WXFQF\KLPITOaJE4WXWPJY[JaQNJWQPRYN[aTSQUDQ
	 QWVIDDHOPHQ[VKZMD	]I_DOG
XYTW[WWPHJQ_	444L[JKLPX_RM[4C444FQF\KLPITOaJyrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
	FQF\KLPITOaJ4444WXyrq|rmeaaM]XaIMI

\G\\a
cFQF\KLPITOaJBBFQF\KLPITOaJL[JKLPX_RM[4XSIN	WaII	YD_X_RM[4XQL[_]VYHT\RVQSY	_M\J[\T
FWDK		WM]TE4444WX~yrq|rmeaaM]XaJSJX
DZZNIIJac\J[\T
FWDK		WM]T]QPJWPK[4WX\FKLS[W	P\QJa_I\J[\T
FWDK		WM]T]QPJWPK[4MZ
[DPaGFyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\~yrq|rmeaaM]XaYVI_UURR
OPac\J[\T
FWDK		WM]T]X_RM[4WXMZ
[DPaGFX_RM[yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
~XRQ]UMZ
[DPaGFrq}ua{fBrq}uap|E4~X]RQM[MZ
[DPaGF44]QPJWPK[4C4]KLL[PJ~yrq|rmeaaM]XaHSO\NMa_Da
c\J[\T
FWDK		WM]T4WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZMD	]I_DOG
_UMYGNJ\	44WXMZ
[DPaGFX_RM[E4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	~XRQ]UMZ
[DPaGFrq}uakp444~X]RQM[MZ
[DPaGF4C4]QPJWPK[4C4JLGE44WXyrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJ 
	
]KLL[PJT_DLVDPGFPFPaDQRK]KLL[PJ4444WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJG
GDOHVVHPLXX_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJGLaSFK[\]aDaX_RM[E4XSIN	WaII	YD_JLK[4]QPJWPK[4C444WX~yrq|rmeaaM]XaURRZW
ITGa
c\J[\T
FWDK		WM]T]QPJWPK[4444HG[[QKZDDYFJN
WLK\P|mnjvSF]
TFJD
`	4RMFMFV[Z[Y[XW\Y[]KLL[PJ4444]KLL[PJOQHNJOXU

GHKP]KLL[PJXYTW[WWPHJQ_	IQ[
HR_	4]KLL[PJyrq|rmeaaM]Xa]H[KYS
JDPXa
cXYTW[WWPHJQ_	
]KLL[PJ4WXyrq|rmeaaM]XaIMI

\G\\a
c]KLL[PJE4QWVIDDHOPHQ[VKZMD	]I_DOG
IQ[
HR_4]QPJWPK[4C4444WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJSF]
TFJDX_RM[BByrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJ_UMYGNJ\	X_RM[E4ZKJSKQZZyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJD	]I_DOG444WUIMLDWX\THZKJSKQZZX_RM[yrq|rmeaaM]Xa[NP\	U	ac]KLL[PJZKJSKQZZ]KLL[PJ44WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cWUIMLDWX\THXYTW[WWPHJQ_	X_RM[yrq|rmeaaM]Xa_K_QN_\W	a]a	cWUIMLDWX\TH_UMYGNJ\	X_RM[yrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_	HG[[QKZDDD	]I_DOG		WUIMLDWX\THE4QWVIDDHOPHQ[VKZMIQ[
HR_
D	]I_DOG	4]QPJWPK[4C44WLJW		OGM
M	yrq|rmeaaM]Xa]H[KYS
JDPXa
cD	]I_DOG	bP]KLL[PJ4WXyrq|rmeaaM]XaIMI

\G\\a
cWLJW		OGM
M	]KLL[PJWLJW		OGM
M	4WLJW		OGM
M	yrq|rmeaaM]Xa]H[KYS
JDPXa
cRYN[aTSQUDQ
	]KLL[PJ4WXyrq|rmeaaM]XaIMI

\G\\a
cWLJW		OGM
M	]KLL[PJWLJW		OGM
M	4KPM[JWLJW		OGM
M	4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJ_UMYGNJ\X_RM[E4QWVIDDHOPHQ[VKZMD	]I_DOG	RYN[aTSQUDQ
	4]QPJWPK[4C4C4WXXSIN	WaII	YD_E4444WX]KLL[PJRMFMFV[Z[Y[XW\Y[]QPJWPK[4KSPWXP]	_UKNR~yrq|rmeaaM]XaHSO\NMa_Da
c\J[\T
FWDK		WM]T4WXyrq|rmeaaM]XaIMI

\G\\a
cKSPWXP]	_UKNR]QPJWPK[4WXyrq|rmeaaM]XaNJ]SSODDIGGaacKSPWXP]	_UKNR 
KSPWXP]	_UKNRT_DLVDPGFPFPaDQRKKSPWXP]	_UKNR4WXKSPWXP]	_UKNRRMFMFV[Z[Y[XW\Y[E4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	_UMYGNJ\	4]QPJWPK[4C4KPM[JKSPWXP]	_UKNR4WX]M_SZD[ODDJ\J[\T
FWDK		WM]T]KLL[PJ]QPJWPK[4WXGXLa_NLOL_P\J[\T
FWDK		WM]T]KLL[PJ]QPJWPK[4WXTO[]UPZVQVUTYT\J[\T
FWDK		WM]T]KLL[PJWUUIP	M_XOZKJ	YHT\J[\T
FWDK		WM]T4]QPJWPK[4C4WXyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
	
]KLL[PJE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	SF]
TFJD	444]QPJWPK[4C4]aaQMVVTVXYTW[WWPHJQ_4WXyrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJ yrq|rmeaaM]Xa_K_QN_\W	a]a	c]KLL[PJ_UMYGNJ\
X_RM[E4\XSFMY]YOJNDX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
E4N\PPTXJ[IUP]~JQU[PaY[Ja_RR]KLL[PJ4WXyrq|rmeaaM]Xa]HYHVUa
cN\PPTXJ[IUP]E4XQL[_]VN\PPTXJ[IUP]_MQQLWVFD]MFLIJE4WXyrq|rmeaaM]Xa]HYHVUa
cQQLWVFD]MFLIJE4WXQQLWVFD]MFLIJecjaqn{pajyBBZ[XWP[ZXYTW[WWPHJQ_	QQLWVFD]MFLIJecjaqn{pajyaiwjva{}vq\XSFMY]YOJNDJLK[4[RM[WXQQLWVFD]MFLIJecja}rqm{ajy\XSFMY]YOJNDX_RM[44C44C4C4KPM[JN\PPTXJ[IUP]QQLWVFD]MFLIJ4444C[RM[E4OGWU\H]IWX\yrq|rmeaaM]XaIOLQOWZKGNaDa		c]KLL[PJD	]I_DOG	444XWR		L	
YMPPyrq|rmeaaM]XaIOLQOWZKGNaDa		c]KLL[PJ_UMYGNJ\
4WXOGWU\H]IWX\X_RM[XWR		L	
YMPPX_RM[BBOGWU\H]IWX\ XWR		L	
YMPP\XSFMY]YOJNDJLK[4KPM[JOGWU\H]IWX\XWR		L	
YMPP4C4WX\XSFMY]YOJND]aaQMVVTV4KPM[J\XSFMY]YOJND4C44SUaDDMyrq|rmeaaM]XaNJ]SSODDIGGaac]KLL[PJ bP4Ga[XY]SZX	Ryrq|rmeaaM]XaXUWXXXT
OYacV]RLTZYOV]RLTZYOayrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIac\J[\T
FWDK		WM]T`FQF\KLPITOaJ4FK[DaRZ]	WSUaDDM]aaQMVVTVG
GDOHVVHPLXbPGa[XY]SZX	RbPGLaSFK[\]aDabP4KPM[JGa[XY]SZX	R4KSPWXP]	_UKNR~yrq|rmeaaM]XaHSO\NMa_Da
c\J[\T
FWDK		WM]T44WXyrq|rmeaaM]XaIMI

\G\\a
cKSPWXP]	_UKNRE4KPM[JRMFMFV[Z[Y[XW\Y[4]QPJWPK[4C4WXyrq|rmeaaM]XaNJ]SSODDIGGaacKSPWXP]	_UKNR 			KSPWXP]	_UKNRT_DLVDPGFPFPaDQRKKSPWXP]	_UKNR4WXKSPWXP]	_UKNRRMFMFV[Z[Y[XW\Y[E4KPM[JKSPWXP]	_UKNRRMFMFV[Z[Y[XW\Y[4QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	IQ[
HR_	4]QPJWPK[444C4KPM[JKSPWXP]	_UKNRRMFMFV[Z[Y[XW\Y[4WX]M_SZD[ODDJ\J[\T
FWDK		WM]T]KLL[PJ]QPJWPK[4WXGXLa_NLOL_P\J[\T
FWDK		WM]T]KLL[PJE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	D	]I_DOG4]QPJWPK[4C4WXTO[]UPZVQVUTYT\J[\T
FWDK		WM]T]KLL[PJFK[DaRZ]	W]QPJWPK[4WUUIP	M_XOZKJ	YHT\J[\T
FWDK		WM]T44XSIN	WaII	YD_JLK[4CXWP_RRGE4WXMZ
[DPaGFX_RM[E4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	~XRQ]UMZ
[DPaGFrq}uakp4~X]RQM[MZ
[DPaGF4C4C4C4L[JKLPXSIN	WaII	YD_4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOG	Q	MNQOPFD4L[JKLPX_RM[4C]_J]V{F][NJWQPQ	MNQOPFDE4L[JKLPX_RM[4C4C4XKP]JWQPWa
[\I\aIPTUPa4E4JLGE4WXZ[XWP[Z_UMYGNJ\	L[JKLP4WX\J

DH]GQG	FQIXTDWYLRT_NPTYMLPL[JKLP4G
SM	KLTZOJP[HKOPMXO	]LQ44RNDT\KHO_LYFJN
WLK\P|mnjvIQ[
HR_	

`	SF]
TFJD	
4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPRYN[aTSQUDQ
	
4XaQDFYTWPJYY\WJKRYWPPS4WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTWF\F
E4444QWVIDDHOPHQ[VKZM_UMYGNJ\	
RYN[aTSQUDQ
	

4L[JKLP4C4WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cXYTW[WWPHJQ_	
L[JKLP444N[	\FIIK]TYUH_LL_G4G
SM	KLTZOJP[HRNDT\KHO_L4G
SM	KLTZOJP[HXYTW[WWPHJQ_	
yrq|rmeaaM]Xa]_HN]GJHLOFRa	
	cIQ[
HR_	
RNDT\KHO_L44VHH_WWH	Z[XWP[ZRYN[aTSQUDQ

ina}qpj{pjazwl|mnjvRYN[aTSQUDQ
SF]
TFJD	4WX~yrq|rmeaaM]XaS

	ZLD	a
cVHH_WWH	E4FLZPH_ZQLP]KURFMDRXVHH_WWH	4WXyrq|rmeaaM]Xa]HYHVUa
cFLZPH_ZE4XQL[_]VFLZPH_Z_MQ	MNQOPFDE44QIQKFOXaHVHH_WWH	Q	MNQOPFD4WX~yrq|rmeaaM]XaS

	ZLD	a
cQIQKFOXaH~yrq|rmeaaM]XaURRZW
ITGa
cQIQKFOXaHE4N[	\FIIK]TYUHecQIQKFOXaHRNDT\KHO_L4\L[_U4C4C4C4C4XQL[_]VN[	\FIIK]TYUH_MG]	VYHD\
E4WX~yrq|rmeaaM]XaVWRNOHYa]Oa	cG]	VYHD\
~yrq|rmeaaM]XaNDD_U_S]R\\acG]	VYHD\
 E4W][NW\IVHD	]I_DOG	
4WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cW][NW\IVHE4XYWDKIRG[TPP[IW][NW\IVH4WX~XYWDKIRG[TP QN[PG]	VYHD\
JLK[E44UGR\XDaTHWX_RM[4PIH_G_	_XaFXYWDKIRG[TP RQ]_J[p_S[aGPQ]VFQS_QaGPQ]VFQS_QD	]I_DOG	
4WXPIH_G_	_XaFX_RM[E4INLNNRRXYWDKIRG[TP MJ_JwPZ[FPIH_G_	_XaF44WXyrq|rmeaaM]Xa]HYHVUa
cINLNNRRWMM[JINLNNRReSF]
TFJD	cWPJINLNNRReRYN[aTSQUDQ
	
c
	E4KKSaOTGF
GXYWDKIRG[TP Y[JxLQSwPZ[FPIH_G_	_XaF4UGR\XDaTHWyrq|rmeaaM]XaIMI

\G\\a
cKKSaOTGF
Gyrq|rmeaaM]XaaQKLGJP]_OIacKKSaOTGF
Gyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTW4KPM[JKKSaOTGF
G4C4KPM[JINLNNRR4C4XYWDKIRG[TP ]RQM[4WXUGR\XDaTHW]QPJWPK[444C4C44C4ZFNXLaR
WNWJSWyrq|rmeaaM]Xa]FMXaRDGSQacG]	VYHD\
4WX~yrq|rmeaaM]XaS

	ZLD	a
cZFNXLaR
WNWJSWMO]\DJR_OJ
	ZVVPZFNXLaR
WNWJSW
JLK[444W][NW\IVHIQ[
HR_	
4DXLZMN
L_FaSPGWN[P	
XIISPKZFNXLaR
WNWJSW_UMYGNJ\	4WXDXLZMN
L_FaX_RM[]QPJWPK[44JQaUXPJFZP[IW][NW\IVH4WX~JQaUXPJFZ QN[PDXLZMN
L_FaW][NW\IVH}l{j{BW][NW\IVHqh{lilwj{JLK[E4JQaUXPJFZ _ZZxLQSmJLWPYaGPQ]VFQS_QaGPQ]VFQS_QD	]I_DOG	XaQDFYTW4JQaUXPJFZ ]RQM[4T[MKFN_]GP[IW][NW\IVH44WX~T[MKFN_]G QN[PDXLZMN
L_FaJLK[E4T[MKFN_]G ]RQM[4WXWWODUHSXYW_HaDXLZMN
L_FaG]	VYHD\
BBVHSVZMU[ZW\LY_QMUMDXLZMN
L_FaG]	VYHD\
_I	Q]G
P
DXLZMN
L_FaE4GTOMLTaWMG
IQPG
G]	VYHD\
ZQYIVUTIDP[XTYXJ4Y_HVRRKFFH]X
]VL
RG]	VYHD\

4C[RM[E4_I	Q]G
P
DXLZMN
L_Fa444C4C[RM[E4_I	Q]G
P
DXLZMN
L_Fa4C4C[RM[E4_I	Q]G
P
DXLZMN
L_Fa4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD	
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQP_]LFFS	QOFKWHHY	I4E4JLGE44WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_BByrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	L[JKLP444WXZ[XWP[ZRYN[aTSQUDQ
	L[JKLP4LKDR	MVMLQJD	]I_DOG	
4WXINaP[FJaM]V[ZKR[ZLKDR	MVMLQJE4INaM]V[ZKR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDac_UMYGNJ\	LKDR	MVMLQJ44C4WXINaP[FJaM]V[ZKR[ZRYN[aTSQUDQ
	E4INaM]V[ZKR[a[H[PJyrq|rmeaaM]XaD]SGTYaFPQHDac
D	]I_DOG		XYTW[WWPHJQ_	4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPSHOMVIGFM4E44JLGE4WXZ[XWP[ZSF]
TFJD	L[JKLP4VKMIRU[[NYFJN
WLK\P|mnjvY4V[RHHJP_LL_G44WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	V[RHHJPecMGUOK\T\L]4V[RHHJPec|mnjvIQ[
HR_
4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
V[RHHJPecKOPMXO	]LQ4XQL[_]VV[RHHJP_MP\[ILWE4LRGJPa	W[DNLXP\[ILWSF]
TFJD	VKMIRU[[N4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacLRGJPa	W[DNLXWPJ~yrq|rmeaaM]Xa_GRUDISIa	cLRGJPa	W[DNLX yrq|rmeaaM]XaD]SGTYaFPQHDac
L[JKLP4C4XQL[_]VV[RHHJP_MP\[ILWE4JQLXNMILDJ]P\[ILWXYTW[WWPHJQ_VKMIRU[[N4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJQLXNMILDJ]E4\PJK_I\DF	SRWPJ~yrq|rmeaaM]Xa_GRUDISIa	cJQLXNMILDJ]4WX\PJK_I\DF	SR yrq|rmeaaM]XaD]SGTYaFPQHDac
		\PJK_I\DF	SRyrq|rmeaaM]XaD]SGTYaFPQHDac]QPJWPK[44_I	Q]G
P
JQLXNMILDJ]4C4TZ]aRWO_RDMJWP\[ILW_UMYGNJ\	VKMIRU[[NSF]
TFJD	4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacTZ]aRWO_RDMJWWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acTZ]aRWO_RDMJW 
		E4444PPRXMJ]UTXP\[ILWD	]I_DOGVKMIRU[[N44MNZS
_S[F~yrq|rmeaaM]XaJSJX
DZZNIIJacPPRXMJ]UTXyrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cPPRXMJ]UTX4WXMNZS
_S[Fyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

~SZaXWR[TZ]aRWO_RDMJWMNZS
_S[FE444~WP]RKZ[TZ]aRWO_RDMJW444L[JKLP4C4WXMNZS
_S[FE44_I	Q]G
P
TZ]aRWO_RDMJW4C4KPM[JPPRXMJ]UTXMNZS
_S[F4C4C4KPM[JJQLXNMILDJ]\PJK_I\DF	SR4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~Z[R[J[aJL_PMW[PJSF]
TFJD4YUVUXKT_aKFVQTS4C]_J]VjVLQI_\R[Q	MNQOPFDE4444QWVIDDHOPHQ[VKZMD	]I_DOG	Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE444C4C444XKP]JWQPQ[G	
QJNTPDJJ4E4JLGE4WXZ[XWP[ZD	]I_DOG	L[JKLP4444J]XS	YI]GXNWTZFPKRR4aGPQ]VFQS_Qyrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP_UMYGNJ\	4J]RFVRDIJNXTDWYLRT_NPTYMLP44XaQDFYTW4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJ]RFVRDIJN~yrq|rmeaaM]XaNDD_U_S]R\\acJ]RFVRDIJN 
	E4]Ja]]RGYPSUZYLLGXD	WRM]	[DJ]RFVRDIJN4WXyrq|rmeaaM]XaIMI

\G\\a
c]Ja]]RGYPSUZyrq|rmeaaM]XaNJ]SSODDIGGaac]Ja]]RGYPSUZ 
	GQS[a	
DD\SGLHV]Ja]]RGYPSUZXaQDFYTW]Ja]]RGYPSUZ44KPM[J]Ja]]RGYPSUZ4C4WXXaQDFYTWE44YKYRaNa

UYFJN
WLK\P|mnjvXYTW[WWPHJQ_	
FF	4HPTMOHYaaVNTyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	~Y[JaQNJWQPYKYRaNa

U4WXHPTMOHYaaVNTBByrq|rmeaaM]XaNJ]SSODDIGGaacHPTMOHYaaVNT


L[JKLP4444XaQDFYTW[YaJUaKFDKPPyrq|rmeaaM]Xa]HN[Q	\\KPOVacHPTMOHYaaVNT4444WXXaQDFYTWBByrq|rmeaaM]XaNJ]SSODDIGGaacXaQDFYTW

L[JKLP4WXGQS[a	
DD\SGLHVXaQDFYTWE4444QWVIDDHOPHQ[VKZMRYN[aTSQUDQ
	RYN[aTSQUDQ
	
4L[JKLP4C4C4G
SM	KLTZOJP[HKOPMXO	]LQ4YOW\[Y
OUZXG
SM	KLTZOJP[H_UMYGNJ\aGPQ]VFQS_Q444[
a\a\HQa
FZYOW\[Y
OUZXaGPQ]VFQS_QRYN[aTSQUDQ
	4WX~yrq|rmeaaM]XaS

	ZLD	a
cYOW\[Y
OUZXMO]\DJR_OJ
	ZVVPYOW\[Y
OUZXFF]_JLK[4UU_U
\LGI\KZDV~yrq|rmeaaM]XaJSJX
DZZNIIJac[
a\a\HQa
FZYLLGXD	WRM]	[D[
a\a\HQa
FZ4J
aXLYJUU_U
\LGI\KZDVPKRR4WXyrq|rmeaaM]XaIMI

\G\\a
cUU_U
\LGI\KZDVUU_U
\LGI\KZDVyrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
	
yrq|rmeaaM]Xa[NP\	U	acUU_U
\LGI\KZDV
T[[IQTX	_FX
H[LMWQPa]QSN_L[T[[IQTX	_FX
ecRINYW\WDWV_QNR
I	 J
aXLYJJLK[4KPM[JT[[IQTX	_FX
4WXJ
aXLYJyrq|rmeaaM]XaIMI

\G\\a
cUU_U
\LGI\KZDVBBUU_U
\LGI\KZDVBByrq|rmeaaM]XaaQKLGJP]_OIacUU_U
\LGI\KZDVyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWE44WXTO[]UPZVQVUTYT[
a\a\HQa
FZG\VSaUWFRZGXaQDFYTWE4Y_HVRRKFFH]X
]VL
R[
a\a\HQa
FZ4I_HUSY[\MMDZQUH[
a\a\HQa
FZ4Xa\
Qa\
N_TU[
a\a\HQa
FZ4C4C4KPM[JUU_U
\LGI\KZDVJ
aXLYJ4I]F\\MV]P	LLKZaGPQ]VFQS_QaGPQ]VFQS_QSF]
TFJD	4_FF[WYX\OG\PQQYLWZWNM]_KP4WX~yrq|rmeaaM]XaS

	ZLD	a
c_FF[WYX\OG~yrq|rmeaaM]XaURRZW
ITGa
c_FF[WYX\OGBB~yrq|rmeaaM]XaS

	ZLD	a
c_FF[WYX\OGMO]\DJR_OJ
	ZVVP_FF[WYX\OGFZXF[JLK[E4FF
KL
\YHJSJ	KX_FF[WYX\OGaGPQ]VFQS_QD	]I_DOG	4ITP	XYY	OM	\T~yrq|rmeaaM]XaJSJX
DZZNIIJacFF
KL
\YHJSJ	KXYLLGXD	WRM]	[DFF
KL
\YHJSJ	KX4JKMMQ
[
\VTDTITP	XYY	OM	\TPKRR4WXyrq|rmeaaM]XaIMI

\G\\a
cITP	XYY	OM	\TITP	XYY	OM	\Tyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_	
yrq|rmeaaM]Xa[NP\	U	acITP	XYY	OM	\T		JKXDPISZYOH[LMWQPa]QSN_L[JKXDPISZYOecRINYW\WDWV_QNR
I	 JKMMQ
[
\VTDTJLK[444KPM[JJKXDPISZYO44WXJKMMQ
[
\VTDTyrq|rmeaaM]XaIMI

\G\\a
cITP	XYY	OM	\TBBITP	XYY	OM	\TBByrq|rmeaaM]XaaQKLGJP]_OIacITP	XYY	OM	\Tyrq|rmeaaM]XaaQKLGJP]_OIacXaQDFYTWE4WXTO[]UPZVQVUTYTFF
KL
\YHJSJ	KXG\VSaUWFRZGXaQDFYTWE4Y_HVRRKFFH]X
]VL
RFF
KL
\YHJSJ	KX4I_HUSY[\MMDZQUHFF
KL
\YHJSJ	KX4Xa\
Qa\
N_TUFF
KL
\YHJSJ	KX4C4C[RM[WXJKMMQ
[
\VTDTE4YO	HXFFMO~yrq|rmeaaM]Xa_GRUDISIa	cFF
KL
\YHJSJ	KX4WXYO	HXFFMOBBYO	HXFFMO		
TJ_	QLHU	YJSMDSOFI_HUSY[\MMDZQUHFF
KL
\YHJSJ	KX4KPM[JYO	HXFFMO444C44KPM[JITP	XYY	OM	\TJKMMQ
[
\VTDT4C4444YFRORF
PPKTSXaQDFYTW4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\		Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4444C4C4XKP]JWQPXXFDNQOGGYKK	a]4E44WXWMM[Jay{jeNcBByrq|rmeaaM]XaIMI

\G\\a
cay{jeNcL[JKLP4444]ILXXM
OMFXGay{jeNc4WX]ILXXM
OMFXGDH_PZM_SHORIRYN[aTSQUDQ
	E4yrq|rmeXYTW[WWPHJQ_	cJLK[4444JLGE4]HJDSO	YJD]MGUOK\T\L]YFJN
WLK\P|mnjvSF]
TFJD		FF_UMYGNJ\	4US
QOIXKSXI~yrq|rmeaaM]XaJSJX
DZZNIIJac]HJDSO	YJD]WPJ~yrq|rmeaaM]XaNDD_U_S]R\\ac]HJDSO	YJD]4WXUS
QOIXKSXI FF\XUS
QOIXKSXIF
]\F\
XE4WP]RKZ[]HJDSO	YJD]4C4C]_J]VjVLQI_\R[Q	MNQOPFDE44C]_J]V{F][NJWQPQ	MNQOPFDE4C4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c ~Q\a[PZa]R[_PE4444C4V[_Z[LIQ[
HR_		44[FWJ4C4WX]ILXXM
OMFXGDH_PZM_SHORIIQ[
HR_		L[JKLP4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG		E4~KNZ_J[aQNJWQPD	]I_DOG
WPJ~Y[JaQNJWQPXYTW[WWPHJQ_
SF]
TFJD	4444~KNZ_J[aQNJWQPRYN[aTSQUDQ
		
yrq|rmeaaM]XaD]SGTYaFPQHDacRYN[aTSQUDQ
	4C444FJMGLYVYXJI_J[aZTNULYVSS
]D	]I_DOG	4WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[ 
`yrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
		FJMGLYVYXJI_J[yrq|rmeaaM]Xa_[
SWPR]NacD	]I_DOG		FJMGLYVYXJI_J[E4JXHU
[aIM~yrq|rmeaaM]Xa]HN[Q	\\KPOVacFJMGLYVYXJI_J[JLK[4WXJXHU
[aIMX_RM[yrq|rmeaaM]XaNJ]SSODDIGGaacJXHU
[aIM 	FJMGLYVYXJI_J[JXHU
[aIM4C44WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[
FJMGLYVYXJI_J[UVLWUT_[UHTD4WXyrq|rmeaaM]XaNJ]SSODDIGGaacFJMGLYVYXJI_J[E4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c ~Q\a[PZa]R[_PE444C4V[_Z[LXYTW[WWPHJQ_			4V[_Z[LRYN[aTSQUDQ
		4V[_Z[LIQ[
HR_		4[FWJ4C4\IK]FWKX\
DaZTNULYVSS
]RYN[aTSQUDQ
	4YSa]GIOPyrq|rmeaaM]XaaQKLGJP]_OIac\IK]FWKX\
DFJMGLYVYXJI_J[4WXWMM[Jam{lh{leXYTW[WWPHJQ_	cyrq|rmeaaM]XaVMQGFWM]acam{lh{leRYN[aTSQUDQ
	cYSa]GIOPE4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c ~Q\a[PZa]R[_PE4C444V[_Z[LXYTW[WWPHJQ_	4V[_Z[LD	]I_DOG	YSa]GIOP444[FWJ4C4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c ~Q\a[PZa]R[_PE4C4V[_Z[L_UMYGNJ\			4V[_Z[LSF]
TFJD		4V[_Z[L_UMYGNJ\	
4V[_Z[LD	]I_DOG	YSa]GIOP4[]VQ\IK]FWKX\
DFJMGLYVYXJI_J[4[FWJ4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD	Q	MNQOPFD4444C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	Q	MNQOPFD4C44C4444XXFDNQOGGYKK	a]4XKP]JWQP__D]_PHWW]4E4WXWMM[Jay{jeRYN[aTSQUDQ
	cL[JKLP4JLGE444NU[Ha\\]K[Z	KXay{jeRYN[aTSQUDQ
	c4444WXyrq|rmeaaM]XaIMI

\G\\a
cNU[Ha\\]K[Z	KXBBNU[Ha\\]K[Z	KXL[JKLP4NU[Ha\\]K[Z	KXyrq|rmeaaM]XaRJLRacNU[Ha\\]K[Z	KX4RN_WZHV_LL_G4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG
RN_WZHVecMJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklravqmj4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	E4QZZL[MHJMJLWPY~Y[JaQNJWQPD	]I_DOG4WXQZZL[MHJRN_WZHVecMJLWPYyrq|rmeaaM]XaaJVVW]M\acQZZL[MHJnvnaklravqmj44C4WXWMM[Jam{lh{leD	]I_DOGcRN_WZHVecMJLWPYam{lh{leIQ[
HR_c4RN_WZHVecWWKaQPMV	TTXKZW_GK4HYNMHYUSKNGX_RM[444XQL[_]Vyrq|rmeaaM]XaUYGQMULaFLa
cRN_WZHV_MDU[L[YMZaMYFWE44WXyrq|rmeaaM]XaIMI

\G\\a
cDU[L[YMZaMYFWBBDU[L[YMZaMYFW]QPJWPK[4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cDU[L[YMZaMYFWX_RM[DU[L[YMZaMYFWyrq|rmeaaM]Xa]H[KYS
JDPXa
cSF]
TFJD		DU[L[YMZaMYFW444WXYFJN
WLK\Pyrq|rmeaaM]XaRJLRacDU[L[YMZaMYFWD	]I_DOG	FF	NU[Ha\\]K[Z	KXE4HYNMHYUSKNGJLK[4\L[_U4C4C44WXHYNMHYUSKNGL[JKLP444]XONUL
O	OJKW]yrq|rmeaaM]XaNWFKW[T\a	cSF]
TFJD	4OU
M_LX
Q[YaJUaKFDKPPLQMN_N_SKUQUTa[K]XONUL
O	OJKW]4IVWR[yrq|rmeaaM]XaVTN_HLNZS_Na
c ~Q\a[PZa]R[_PE4C4V[_Z[LSF]
TFJD	4V[_Z[LRYN[aTSQUDQ
	4[]VQOU
M_LX
Q]XONUL
O	OJKW]_UMYGNJ\	yrq|rmeaaM]XaaQKLGJP]_OIac]XONUL
O	OJKW]XYTW[WWPHJQ_	4[FWJ4444C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_	
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4444QWVIDDHOPHQ[VKZMD	]I_DOG	Q	MNQOPFD4C4C4__D]_PHWW]4XKP]JWQPJ]_O\[OMVYGFX
WGX4E4HYNMHYUSKNGJLK[4KPZMJFF[aVXKP]JWQP_U
D[N	FYQMQYKM[HYNMHYUSKNGE4JLGE4yrq|rmeaaM]XaUQHVIIDGac_U
D[N	FYQMQY4C]_J]VjVLQI_\R[Q	MNQOPFDE44HYNMHYUSKNGX_RM[44C]_J]V{F][NJWQPQ	MNQOPFDE4HYNMHYUSKNGX_RM[4C4C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	KPZMJFF[aV_UMYGNJ\	4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
		KPZMJFF[aVXYTW[WWPHJQ_	4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	KPZMJFF[aVIQ[
HR_	4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
KPZMJFF[aVSF]
TFJD4[RM[WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cXYTW[WWPHJQ_yrq|rmeaaM]Xa__VX_]O[ac_UMYGNJ\SF]
TFJDKPZMJFF[aV_LL_GSF]
TFJDSF]
TFJD4WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cRYN[aTSQUDQ

yrq|rmeaaM]Xa__VX_]O[acIQ[
HR_
RYN[aTSQUDQ
KPZMJFF[aV_LL_GRYN[aTSQUDQ

SF]
TFJD4WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cSF]
TFJDyrq|rmeaaM]Xa__VX_]O[acSF]
TFJDIQ[
HR_	KPZMJFF[aV_LL_G_UMYGNJ\SF]
TFJD4444WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\KPZMJFF[aVXYTW[WWPHJQ_444[RM[WXWMM[Jyrq|rmeXYTW[WWPHJQ_cyrq|rmeaaM]XaJFVY[	SJPKa	cyrq|rmeRYN[aTSQUDQ
cyrq|rmeaaM]Xa__VX_]O[acyrq|rmeSF]
TFJDcD	]I_DOGKPZMJFF[aVXKP]JWQPE4yrq|rmeRYN[aTSQUDQ
c Z[R[J[}_]V[JLK[4444C4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_KPZMJFF[aVRYN[aTSQUDQ
4WXyrq|rmeaaM]Xa[	aQ\_KWK[Xa
cXYTW[WWPHJQ_
yrq|rmeaaM]Xa__VX_]O[acSF]
TFJD
SF]
TFJDKPZMJFF[aV_LL_GXYTW[WWPHJQ_RYN[aTSQUDQ
444QWVIDDHOPHQ[VKZM_UMYGNJ\

IQ[
HR_	4L[JKLPHYNMHYUSKNG4C4XKP]JWQPOaN_QXXF_LNXP	\4444E4444WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
		WMa_ZSWPL[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_INaZQWPYa_T_FL[JKLPJLK[4WXZ[XWP[ZD	]I_DOGl{mjal{ok{mjL[JKLPJLK[4WXZ[XWP[ZIQ[
HR_fsrln}al{ok{mjL[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDWMaX[[ZL[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDWMaLQ\QJML[JKLPJLK[4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_WMaMWJ[S_NML[JKLPJLK[4444WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
WMa]KMJQSWD[aNL[HW[IL[JKLPJLK[4WXWMM[Jay{jeD	]I_DOGcBBWMM[Jay{jeIQ[
HR_cBBWMM[Jay{jeIQ[
HR_	cL[JKLPJLK[44L[JKLPX_RM[4C44XKP]JWQPRUQOX\
]Ha4E444VLJJ]]DDWMM[Jyrq|rmeSF]
TFJDcyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeSF]
TFJDcyrq|rmeaaM]XaVMQGFWM]acyrq|rmeIQ[
HR_c4WXVLJJ]]DDL[JKLP4VLJJ]]DDyrq|rmeaaM]XaXUWXXXT
OYacSF]
TFJDXYTW[WWPHJQ_VLJJ]]DD4YZVKGOJaG	aUQyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
MJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklravqmj4YQ
TZP_SLV[
_YFJN
WLK\Pyrq|rmeaaM]XaRJLRacYZVKGOJaG	aUQ4Q\G
\SJGW	K[yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacVLJJ]]DD4L[JKLPbPM]LWNJZ_J_M]bYQ
TZP_SLV[
_Q\G
\SJGW	K[b bPVLJJ]]DDbPM]LWNJ bPM]YQ
TZP_SLV[
_Q\G
\SJGW	K[ bP444C4XKP]JWQPMWQIZ]UWG
QDUY\ID]Z4E44JLGE444WXOaN_QXXF_LNXP	\L[JKLP4LPNDPMIPMHRUQOX\
]Ha4WXLPNDPMIPMHL[JKLP444[]VQLPNDPMIPMH4yrq|rmeRYN[aTSQUDQ

cJLK[4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\yrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
		[SNJGyrq|rme_UMYGNJ\cE4yrq|rmeRYN[aTSQUDQ
cJLK[4IQLaW\IVSYWPJ~Y[JaQNJWQP_UMYGNJ\
4WXyrq|rmeaaM]XaD]SGTYaFPQHDacIQLaW\IVSY 	~KNZ_J[aQNJWQP_UMYGNJ\yrq|rmeaaM]XaD]SGTYaFPQHDacD	]I_DOG	4KPM[JIQLaW\IVSY4444C4C]_J]VjVLQI_\R[Q	MNQOPFDE444QWVIDDHOPHQ[VKZMD	]I_DOGQ	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPINRR\VFK
M	DWS_\DGVLSUF_JJ_WNI	[SLJ
	_[ND4E4WXyrq|rmeaaM]XaIMI

\G\\a
cDGVLSUF_JJBBDGVLSUF_JJL[JKLPDGVLSUF_JJ4WXZ[XWP[ZIQ[
HR__WNI	[SLJ
	_[NDnvnaqkjnkjavpzr{laxwprL[JKLPDGVLSUF_JJ4WX[SNJGyrq|rmeSF]
TFJD	cL[JKLPDGVLSUF_JJ4WX[SNJGyrq|rmeRYN[aTSQUDQ

cL[JKLPDGVLSUF_JJ4WXyrq|rmeaaM]XaNJ]SSODDIGGaacDGVLSUF_JJ 



L[JKLPDGVLSUF_JJ4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
E4444XQL[_]V_LL_G~V[_Z[LMaRWMJ_MJWKIZSXa\MWQE4WXMJLWNQMJWKIZSXa\MWQD	]I_DOG	MJLWNQMJWKIZSXa\MWQRYN[aTSQUDQ
X_RM[L[JKLPDGVLSUF_JJ4WXMJLWNQMJWKIZSXa\MWQ_UMYGNJ\MJLWNQMJWKIZSXa\MWQXYTW[WWPHJQ_
X_RM[MJLWNQMJWKIZSXa\MWQRYN[aTSQUDQ

X_RM[L[JKLPDGVLSUF_JJ4C4KPM[JJWKIZSXa\MWQ4C4LPNDPMIPMHRUQOX\
]Ha4WXLPNDPMIPMHL[JKLPDGVLSUF_JJ4WXMJLWNQMDGVLSUF_JJ_UMYGNJ\
X_RM[MJLWNQMDGVLSUF_JJRYN[aTSQUDQ

X_RM[L[JKLPDGVLSUF_JJ4yrq|rmeRYN[aTSQUDQ


cJLK[4yrq|rmeXYTW[WWPHJQ_
cJLK[4IVVVPD[VHQ]WMJLWNQMDGVLSUF_JJRYN[aTSQUDQ

4WXIVVVPD[VHQ]WX_RM[E4L[JKLPyrq|rmeaaM]Xa[NP\	U	acDGVLSUF_JJIVVVPD[VHQ]WLPNDPMIPMHyrq|rmeaaM]Xa[NP\	U	acDGVLSUF_JJIVVVPD[VHQ]W4C4L[JKLPDGVLSUF_JJLPNDPMIPMH4C4XKP]JWQPPN]M
DW]
OKZODVGNM[4E4JLGE4WXOaN_QXXF_LNXP	\L[JKLP4WX[SNJGyrq|rmeSF]
TFJD	cL[JKLP4WX[SNJGyrq|rmeD	]I_DOG
	cL[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
L[JKLP4VLJJ]]DDWMM[Jyrq|rmeRYN[aTSQUDQ
cyrq|rmeaaM]XaIMI

\G\\a
cyrq|rmeRYN[aTSQUDQ
cyrq|rmeaaM]XaVMQGFWM]acyrq|rmeXYTW[WWPHJQ_c4WXVLJJ]]DDL[JKLP4WIKaJL	NWMM[Jam{lh{leIQ[
HR_
cMJLWPYam{lh{leIQ[
HR_
c444WXWIKaJL	Nyrq|rmeaaM]Xa_[
SWPR]NacXYTW[WWPHJQ_WIKaJL	NL[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_
E4XQL[_]V_LL_G~V[_Z[LMaRWMJ_MJWKIZSXa\MWQE4WXMJLWNQMJWKIZSXa\MWQRYN[aTSQUDQ
	MJLWNQMJWKIZSXa\MWQ_UMYGNJ\X_RM[L[JKLP444WXMJLWNQMJWKIZSXa\MWQIQ[
HR_MJLWNQMJWKIZSXa\MWQSF]
TFJDX_RM[MJLWNQMJWKIZSXa\MWQD	]I_DOG
X_RM[L[JKLP444WXMJLWNQMJWKIZSXa\MWQXYTW[WWPHJQ_L[JKLP4C4KPM[JJWKIZSXa\MWQ4C4yrq|rme_UMYGNJ\
	cJLK[4444~yrq|rmeaaM]XaDXH_IGJa
cRYN[aTSQUDQ
4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZM_UMYGNJ\
Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4XKP]JWQPMaWOSaS[VIO
FXWJY4E4JLGE4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG		L[JKLP4WXWMa_ZSWPWMM[Jyrq|rmeSF]
TFJDcBByrq|rmeSF]
TFJDcD	]I_DOG
L[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ

	WMaMMRL[JKLP4HSHWXP]
WaZTNULYVSS
]SF]
TFJD

4YQ
TZP_SLV[
_YFJN
WLK\P|mnjv_UMYGNJ\	
4SGDQ_VIHJ
XIMRIQ[
HR_4WXHSHWXP]
WE4444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGWPJ~Y[JaQNJWQPRYN[aTSQUDQ
E4~KNZ_J[aQNJWQPD	]I_DOGIQ[
HR_	4YM\LOL	\MJLWPY~Y[JaQNJWQPD	]I_DOG4[]VQbPD	]I_DOGYQ
TZP_SLV[
_ 4D	]I_DOG4XYTW[WWPHJQ_SGDQ_VIHJ
XIMRRYN[aTSQUDQ
_UMYGNJ\
4RYN[aTSQUDQ
yrq|rmeaaM]XaZNPRLPO\YVYacYM\LOL	\4SF]
TFJDSGDQ_VIHJ
XIMRIQ[
HR_	SF]
TFJD4D	]I_DOGSGDQ_VIHJ
XIMRXYTW[WWPHJQ_	XYTW[WWPHJQ_	SGDQ_VIHJ
XIMRSF]
TFJD	RYN[aTSQUDQ
	SGDQ_VIHJ
XIMRSF]
TFJD	
D	]I_DOG	SGDQ_VIHJ
XIMRSF]
TFJD	D	]I_DOG		4XYTW[WWPHJQ_	SGDQ_VIHJ
XIMRIQ[
HR_	D	]I_DOGSGDQ_VIHJ
XIMRIQ[
HR_D	]I_DOG4SF]
TFJDbP4KPM[JYM\LOL	\4C4L[JKLP4444C4HSHWXP]
Wyrq|rmeaaM]XaXUWXXXT
OYacIQ[
HR_
_UMYGNJ\

HSHWXP]
W4WXyrq|rmeaaM]Xa_K_QN_\W	a]a	cHSHWXP]
WD	]I_DOG

HSHWXP]
WIQ[
HR_

yrq|rmeaaM]XaHF	ULKWWW]ZacHSHWXP]
W4IR_JI	_K[HWX	I4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJD
E4HGD\MWOSJ\QG	VMJLWPYyrq|rmeaaM]XaaJVVW]M\acVQS[aKLRnvnaklranjv4WXHGD\MWOSJ\QG	VHGD\MWOSJ\QG	VIR_JI	_K[HWX	Iyrq|rmeaaM]XaNGLV\SLPGacHGD\MWOSJ\QG	V4C4WXyrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_		E44~KNZ_J[aQNJWQP_UMYGNJ\SF]
TFJD
4~KNZ_J[aQNJWQPD	]I_DOGHSHWXP]
WXYTW[WWPHJQ_
4C444HJNX\_MG\D	]I_DOGYQ
TZP_SLV[
_ 4_UMYGNJ\4RYN[aTSQUDQ
SGDQ_VIHJ
XIMRXYTW[WWPHJQ__UMYGNJ\4D	]I_DOG4_UMYGNJ\	SGDQ_VIHJ
XIMRRYN[aTSQUDQ
SF]
TFJDyrq|rmeaaM]XaZNPRLPO\YVYacHSHWXP]
W4IQ[
HR_SGDQ_VIHJ
XIMRSF]
TFJD	RYN[aTSQUDQ
	SGDQ_VIHJ
XIMRRYN[aTSQUDQ
D	]I_DOG	SGDQ_VIHJ
XIMR_UMYGNJ\XYTW[WWPHJQ_	SGDQ_VIHJ
XIMRSF]
TFJD	IQ[
HR_yrq|rmeaaM]XaZNPRLPO\YVYacHSHWXP]
WIQ[
HR_
4_UMYGNJ\SGDQ_VIHJ
XIMRRYN[aTSQUDQ
_UMYGNJ\yrq|rmeaaM]XaZNPRLPO\YVYacHSHWXP]
W_UMYGNJ\	yrq|rmeaaM]XaZNPRLPO\YVYacIR_JI	_K[HWX	IIQ[
HR_SGDQ_VIHJ
XIMRXYTW[WWPHJQ_IQ[
HR_4_UMYGNJ\SGDQ_VIHJ
XIMRSF]
TFJDD	]I_DOG444IQ[
HR_	SGDQ_VIHJ
XIMRIQ[
HR__UMYGNJ\SGDQ_VIHJ
XIMRSF]
TFJDXYTW[WWPHJQ_
44XYTW[WWPHJQ_SGDQ_VIHJ
XIMRRYN[aTSQUDQ
	RYN[aTSQUDQ
4_UMYGNJ\	4IQ[
HR_	SGDQ_VIHJ
XIMRD	]I_DOGSF]
TFJD4444XYTW[WWPHJQ_SGDQ_VIHJ
XIMRSF]
TFJD	SF]
TFJDSGDQ_VIHJ
XIMRSF]
TFJD_UMYGNJ\4IQ[
HR_4[]VQbPHJNX\_MG\bP4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMSF]
TFJD
Q	MNQOPFD44C]_J]V{F][NJWQPQ	MNQOPFDE4QWVIDDHOPHQ[VKZMD	]I_DOG
Q	MNQOPFD4C4C44WXSFaYJ
TI	D
MaGE4L[JKLP4C4YU[X]PK	S
[4O\RMSPa
IQ~yrq|rmeaaM]Xa_GRUDISIa	cXTDWYLRT_NPTYMLP44WXO\RMSPa
IQBBO\RMSPa
IQ

		TJ_	QLHU	YJSMDSOFE4MGTOO
IXNXyrq|rmeaaM]XaD]SGTYaFPQHDac4444GTOMLTaWMG
IQPG
XTDWYLRT_NPTYMLPMGTOO
IXNXMGTOO
IXNX
TJ_	QLHU	YJSMDSOF444KPM[JMGTOO
IXNX4C44KPM[JO\RMSPa
IQ4GFL][MK]ISyrq|rmeaaM]Xa]FMXaRDGSQacaaxwr{aaSF]
TFJDyrq|rmeaaM]Xa[KDO
YMUaR\Vacaaxwr{aaRYN[aTSQUDQ
	4Q\]FGJPFSHJ~yrq|rmeaaM]XaJSJX
DZZNIIJacGFL][MK]ISWPJ~yrq|rmeaaM]Xa_GRUDISIa	cGFL][MK]IS44\MWQM[RMRGQ\]FGJPFSHJ yrq|rmeaaM]XaD]SGTYaFPQHDacFFQ\]FGJPFSHJyrq|rmeaaM]XaD]SGTYaFPQHDac4WX\MWQM[RMRG~yrq|rmeaaM]XaKHLOSPVW]RWJa	cGFL][MK]IS4KPM[JGFL][MK]ISQ\]FGJPFSHJ4WX\MWQM[RMRGJLGE4X]SIOK\GJaaxwr{aa444MYZYKR]YXDWF4R\\_HXVKG~yrq|rmeaaM]XaHSO\NMa_Da
cX]SIOK\GJX_RM[PKRR
4WXyrq|rmeaaM]XaIMI

\G\\a
cR\\_HXVKGyrq|rmeaaM]Xa_[
SWPR]NacSF]
TFJD	
R\\_HXVKGDJY]SOHDaMYZYKR]YXDWFDJY]SOHDaec44WXMYZYKR]YXDWFZ[XWP[ZSF]
TFJD
E4JVF_FWND[GIRU_LL_G44\PFPJ]KL_WLSZ[XWP[ZD	]I_DOGinskanrkywpazwlina}qpj{pjazwlSF]
TFJD
4KMXVYPSLMOZ[XWP[ZIQ[
HR_inanrkywpazwlina}qpj{pjazwl_UMYGNJ\		4444YLSNWH_][KHX_RM[4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4[
R[IZXaDGaFO~yrq|rmeaaM]XaS

	ZLD	a
c\PFPJ]KL_WLS~yrq|rmeaaM]Xa\TOUSOOMFG\a	c\PFPJ]KL_WLSIQ[
HR_X_RM[4U
YP
GRZSXS~yrq|rmeaaM]Xa\TOUSOOMFG\a	cKMXVYPSLMORYN[aTSQUDQ
	4WXyrq|rmeaaM]Xa]HYHVUa
c[
R[IZXaDGaFOBByrq|rmeaaM]Xa]HYHVUa
cU
YP
GRZSXSE4YLSNWH_][KHJLK[4XQL[_]V_LL_G[
R[IZXaDGaFO_MD[_\	PS[[KDXJVF_FWND[GIRUecD[_\	PS[[KDX4444XQL[_]V_LL_GU
YP
GRZSXS_MD[_\	PS[[KDXJVF_FWND[GIRUecD[_\	PS[[KDX4C4KPM[J[
R[IZXaDGaFOU
YP
GRZSXS4C4WXYLSNWH_][KHE4\HSYYZTXa[~yrq|rmeaaM]XaS

	ZLD	a
c\PFPJ]KL_WLSQLP]KURFMDRX\PFPJ]KL_WLS
X_RM[444WXyrq|rmeaaM]Xa]HYHVUa
c\HSYYZTXa[XQL[_]V\HSYYZTXa[_M_D\Y]LV\IYOE4WXyrq|rmeaaM]Xa[NP\	U	ac_D\Y]LV\IYOXYTW[WWPHJQ_JVF_FWND[GIRUec\PFPJ]KL_WLS_D\Y]LV\IYO4444C444\HSYYZTXa[~yrq|rmeaaM]XaS

	ZLD	a
cKMXVYPSLMOQLP]KURFMDRXKMXVYPSLMOF]F]X_RM[4WXyrq|rmeaaM]Xa]HYHVUa
c\HSYYZTXa[XQL[_]V\HSYYZTXa[_M_D\Y]LV\IYOE444VXVLORT	XDGQUKMXVYPSLMO_D\Y]LV\IYO44WX~yrq|rmeaaM]XaS

	ZLD	a
cVXVLORT	XDGQU]QPJWPK[4UGO	KYH[DKXQLP]KURFMDRXVXVLORT	XDGQUF\F_[Z4WXyrq|rmeaaM]Xa]HYHVUa
cUGO	KYH[DKX]QPJWPK[4XQL[_]VUGO	KYH[DKX_MPSQaJVIJIFXE4WXyrq|rmeaaM]Xa[NP\	U	acPSQaJVIJIFXFFRYN[aTSQUDQ
	JVF_FWND[GIRUecVXVLORT	XDGQUPSQaJVIJIFX44C444C4KPM[J\HSYYZTXa[_D\Y]LV\IYOPSQaJVIJIFXVXVLORT	XDGQUUGO	KYH[DKX4C4INGS[Z][
Lyrq|rmeaaM]Xa[KDO
YMUaR\VacX]SIOK\GJXYTW[WWPHJQ_	4XQL[_]VJVF_FWND[GIRU_MD[_\	PS[[KDXE4WXD[_\	PS[[KDXX]SIOK\GJ]QPJWPK[4HFKSLJMa~yrq|rmeaaM]Xa_GRUDISIa	cD[_\	PS[[KDX444WXHFKSLJMaBBHFKSLJMaF[F_	[
		E4\T_UKYVTXURK~yrq|rmeaaM]XaNDD_U_S]R\\acD[_\	PS[[KDX44WX\T_UKYVTXURKBB\T_UKYVTXURK

BB\T_UKYVTXURK 

		
	]QPJWPK[4C444R\\_HXVKG~yrq|rmeaaM]XaHSO\NMa_Da
cD[_\	PS[[KDXX_RM[PKRR

4DJY]SOHDa_LL_G4WXyrq|rmeaaM]XaIMI

\G\\a
cR\\_HXVKGyrq|rmeaaM]Xa_[
SWPR]NacIQ[
HR_	
R\\_HXVKGDJY]SOHDa4WX[SNJGDJY]SOHDaecE4444WXaKIGURZU\I_P
SaFD[_\	PS[[KDX

]QPJWPK[4DJY]SOHDa_LL_GIQ[
HR_44C4WXyrq|rmeaaM]Xa[KDO
YMUaR\VacD[_\	PS[[KDXD	]I_DOG	INGS[Z][
LDJY]SOHDaecMYZYKR]YXDWFE4WXJXQZWQYO][P\VZD[_\	PS[[KDXE4WXWWODUHSXYW_HaD[_\	PS[[KDXD[_\	PS[[KDX_UMYGNJ\	yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_	~QN]_]V[aWPH_RWZ_J[D[_\	PS[[KDXJLK[44C4]QPJWPK[4C4WXH[LMWQPa]QSN_L[DJY]SOHDaecMYZYKR]YXDWFE4L	J	F]\	PWOFFGWURYH]M[D[_\	PS[[KDX4WXL	J	F]\	X_RM[E4QWVIDDHOPHQ[VKZMD	]I_DOGRYN[aTSQUDQ
yrq|rmeaaM]Xa[KDO
YMUaR\VacD[_\	PS[[KDX444]QPJWPK[44C4WXL	J	F]\	JLK[E4WXWWODUHSXYW_HaD[_\	PS[[KDXD[_\	PS[[KDXIQ[
HR_	E444WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~QN]_]V[aWPH_RWZ_J[D[_\	PS[[KDXJLK[4444C[RM[WXY[D\QVWZZP_D[_\	PS[[KDXMQ\WLYZaV
PWT	KHUZD[_\	PS[[KDXE4IHPXVXNL_VN\MGYaMD[_\	PS[[KDX4[TSM]VFID	aQPDD[_\	PS[[KDX44C4~yrq|rmeaaM]XaYR\Y]GUO[a	cyrq|rmeaaM]Xa]FMXaRDGSQacD[_\	PS[[KDX_UMYGNJ\yrq|rmeaaM]Xa[KDO
YMUaR\VacD[_\	PS[[KDXXYTW[WWPHJQ_4]QPJWPK[4C4WXY[D\QVWZZP_D[_\	PS[[KDXMQ\WLYZaV
PWT	KHUZD[_\	PS[[KDXE4IHPXVXNL_VN\MGYaMD[_\	PS[[KDX4[TSM]VFID	aQPDD[_\	PS[[KDX44C4LODXSO\LJYYK	YKVIVPZD[_\	PS[[KDX4]QPJWPK[4C44TDO[TS_JSIOT
yrq|rmeaaM]Xa[KDO
YMUaR\Vacyrq|rmeaaM]Xa]FMXaRDGSQacD[_\	PS[[KDXRYN[aTSQUDQ
BByrq|rmeaaM]Xa]FMXaRDGSQacD[_\	PS[[KDX\PFPJ]KL_WLS4WXTDO[TS_JSIOT
yrq|rmeaaM]XaIVPaITaGa
cIQ[
HR_E4444IJX_FNWyrq|rmeaaM]Xa[KDO
YMUaR\Vacyrq|rmeaaM]Xa]FMXaRDGSQacD[_\	PS[[KDXyrq|rmeaaM]Xa[KDO
YMUaR\VacD[_\	PS[[KDX4FRY_LL_G~Y[JaQNJWQPXYTW[WWPHJQ_	_LL_G4TDO[TS_JSIOT
yrq|rmeaaM]Xa_LHMQPFPD
Ma
cIJX_FNWFRYJLK[44WXTDO[TS_JSIOT
yrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_	WMaSKRJWMWJ[yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOGE4U\TMLT\]XIM[_LL_G~Y[JaMWJ[aQNJWQPRYN[aTSQUDQ
_LL_G4TDO[TS_JSIOT
WMM[JU\TMLT\]XIM[eIJX_FNWc4KPM[JU\TMLT\]XIM[44C4KPM[JIJX_FNWFRY4C4WXTDO[TS_JSIOT
]QPJWPK[4WXH[LMWQPa]QSN_L[DJY]SOHDaecMYZYKR]YXDWF E4WXJXQZWQYO][P\VZD[_\	PS[[KDXPa
X\SYQJTY	
][YKD[_\	PS[[KDXM]VKWGRWZRNYD[_\	PS[[KDXX]SIOK\GJL[JKLP4ZF
V]_ORyrq|rmeaaM]Xa]FMXaRDGSQacD[_\	PS[[KDXD	]I_DOGyrq|rmeaaM]XaaQKLGJP]_OIacD[_\	PS[[KDX4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacZF
V]_ORWPJ~yrq|rmeaaM]Xa_GRUDISIa	cZF
V]_ORyrq|rmeaaM]XaD]SGTYaFPQHDacFF_E4NJI
ZHMIYQG\M\Kyrq|rmeaaM]XaZLWL
M]XJPacBMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cZF
V]_OR4WXyrq|rmeaaM]XaOG\FSVKacNJI
ZHMIYQG\M\KBBNJI
ZHMIYQG\M\KecDJY]SOHDaecBBWPJNJI
ZHMIYQG\M\KecWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acD[_\	PS[[KDXE4~yrq|rmeaaM]XaYR\Y]GUO[a	cZF
V]_OR4]QPJWPK[4C4WXPWOFFGWURYH]M[D[_\	PS[[KDXX_RM[E4Y_HVRRKFFH]X
]VL
RD[_\	PS[[KDX44WX_I	Q]G
P
D[_\	PS[[KDXE4~yrq|rmeaaM]XaYR\Y]GUO[a	cZF
V]_OR4WXyrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG	~QN]_]V[aWPH_RWZ_J[D[_\	PS[[KDXJLK[4C4C4]QPJWPK[4C4~yrq|rmeaaM]XaUM_SDP\\\a
cZF
V]_ORDJY]SOHDaecBWPJ~yrq|rmeaaM]XaNDD_U_S]R\\acD[_\	PS[[KDX4444]QPJWPK[4C4WXDJY]SOHDaecMYZYKR]YXDWFE4NGMLWGa
DYYFLN]J\S]QRWHRR4444GRRX
XY
YX_RM[4WX[SNJGNGMLWGa
DeXYTW[WWPHJQ_cE4KHL_
KNJa~yrq|rmeaaM]XaI	WS[XMPacNGMLWGa
De_UMYGNJ\
c4TDYSUaXO\W~yrq|rmeaaM]XaI	WS[XMPacD[_\	PS[[KDX4WXyrq|rmeaaM]XaIMI

\G\\a
cKHL_
KNJayrq|rmeaaM]XaIMI

\G\\a
cTDYSUaXO\WKHL_
KNJaTDYSUaXO\WTKH_JGFTZLTG]NGMLWGa
DRYN[aTSQUDQ
JXQZWQYO][P\VZD[_\	PS[[KDXE4WXM]VKWGRWZRNYD[_\	PS[[KDXX]SIOK\GJGRRX
XY
YJLK[4[RM[L[JKLP4C4WXyrq|rmeaaM]XaIMI

\G\\a
cKHL_
KNJaKHL_
KNJa~yrq|rmeaaM]XaI	WS[XMPacX]SIOK\GJGRRX
XY
YJLK[4C4WXGRRX
XY
YJXQZWQYO][P\VZD[_\	PS[[KDXE4WXPa
X\SYQJTY	
][YKD[_\	PS[[KDXBBPWOFFGWURYH]M[D[_\	PS[[KDXX_RM[E4WXWWODUHSXYW_HaD[_\	PS[[KDXD[_\	PS[[KDXIQ[
HR_	yrq|rmeaaM]XaIVPaITaGa
cD	]I_DOG~QN]_]V[aWPH_RWZ_J[D[_\	PS[[KDXJLK[4C4KPM[JNGMLWGa
DGRRX
XY
YKHL_
KNJaTDYSUaXO\W4]QPJWPK[4444C4WXGRRX
XY
Yyrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacyrq|rmeaaM]Xa[KDO
YMUaR\VacD[_\	PS[[KDXRYN[aTSQUDQ
FF yrq|rmeaaM]Xa[NP\	U	acyrq|rmeaaM]XaaQKLGJP]_OIacINGS[Z][
L
E444WXM]VKWGRWZRNYD[_\	PS[[KDXX]SIOK\GJL[JKLP4C4KPM[JNGMLWGa
DGRRX
XY
YKHL_
KNJaTDYSUaXO\W4C444C4C4KPM[JX]SIOK\GJMYZYKR]YXDWFR\\_HXVKGDJY]SOHDaJVF_FWND[GIRU\PFPJ]KL_WLSKMXVYPSLMOD[_\	PS[[KDXHFKSLJMaINGS[Z][
L\T_UKYVTXURKL	J	F]\	ZF
V]_ORNJI
ZHMIYQG\M\K44C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE44C4KPM[J\MWQM[RMRG4WXWMM[Jyrq|rmeSF]
TFJDcE44WXH[LMWQPa]QSN_L[MJLWPYyrq|rmeXYTW[WWPHJQ_cRINYW\WDWV_QNR
I	SF]
TFJD	L[JKLP4yrq|rmeXYTW[WWPHJQ_c4C[RM[WXZ[XWP[ZD	]I_DOGE4GHUaW_D
G\YGaJ
]QPMJ_PJIQ[
HR_4WXyrq|rmeaaM]XaIMI

\G\\a
cGHUaW_D
G\YGaJ
yrq|rmeaaM]Xa_[
SWPR]NacRYN[aTSQUDQ
GHUaW_D
G\YGaJ
H[LMWQPa]QSN_L[GHUaW_D
G\YGaJ
RINYW\WDWV_QNR
I	SF]
TFJDL[JKLP4yrq|rmeXYTW[WWPHJQ_c4KPM[JGHUaW_D
G\YGaJ
4444C4yrq|rmeIQ[
HR_cRINYW\WDWV_QNR
I	4WXyrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_
~]R[_LMJ_J]_]V[JLK[XTDWYLRT_NPTYMLP4yrq|rmeIQ[
HR_cMJLWPY~yrq|rmeaaM]XaNDD_U_S]R\\acXTDWYLRT_NPTYMLPMJLWPY~yrq|rmeaaM]Xa_GRUDISIa	cXTDWYLRT_NPTYMLP4WXZ[XWP[ZIQ[
HR_Z[XWP[SF]
TFJDRINYW\WDWV_QNR
I	4444WXZ[XWP[ZIQ[
HR_Z[XWP[XYTW[WWPHJQ_RINYW\WDWV_QNR
I	4PTaaNIZYOT
I_aSF]
TFJD44NGWWUNHW]Z[KG]SOOXTDWYLRT_NPTYMLP4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
	E444JLGE44IDWUKL
D\PQQYLWZWNM]_KP4WX~yrq|rmeaaM]XaS

	ZLD	a
cIDWUKL
DE4D
[VUILRD_\KQVKYYDIHNYQPMT4XRLFIH]NQLP]KURFMDRXIDWUKL
D	4WXyrq|rmeaaM]Xa]HYHVUa
cXRLFIH]NE4444XQL[_]VXRLFIH]N_M[aLSR\TQ\DS	UE4WX[aLSR\TQ\DS	UD
[VUILRD_\KQ]QPJWPK[4WXyrq|rmeaaM]XaRJLRacyrq|rmeaaM]XaQVIZMF
UWMPac[aLSR\TQ\DS	U]QPMJ_PJRYN[aTSQUDQ
	SF]
TFJD]QPJWPK[4YH_OPKN\_O_TIDWUKL
D[aLSR\TQ\DS	U4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacYH_OPKN\_O_T~yrq|rmeaaM]XaNDD_U_S]R\\acYH_OPKN\_O_T 	aKIGURZU\I_P
SaFYH_OPKN\_O_TE44]\PVKDPXDNGR]aTYH_OPKN\_O_T44C4C4C4C4C]_J]VjVLQI_\R[Q	MNQOPFDE4QWVIDDHOPHQ[VKZMXYTW[WWPHJQ_Q	MNQOPFD4C]_J]V{F][NJWQPQ	MNQOPFDE4C444C44WXOWSW[YWPZ	XJME4\GXT\HI_L]RNIQ[
HR_
XYTW[WWPHJQ_44C4444yrq|rme_UMYGNJ\	
c_LL_G4yrq|rmeD	]I_DOGc_LL_G4yrq|rmeIQ[
HR_c4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4yrq|rmeaaM]XaKQTGQ
Na	cXYTW[WWPHJQ_
4yrq|rmeaaM]XaKQTGQ
Na	cSF]
TFJD
4444C44HF[IVZQKNRyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPRYN[aTSQUDQ

yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLP_UMYGNJ\
4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacHF[IVZQKNRE4FW\\LIVW	[Xyrq|rmeaaM]XaVMQGFWM]acMJLWPY~yrq|rmeaaM]XaHSO\NMa_Da
cHF[IVZQKNR4W]	XL]XaXFXHTUPNDHRS\4WXFW\\LIVW	[XBBW]	XL]XaXFXHFW\\LIVW	[XW]	XL]XaXFXH_I	Q]G
P
HF[IVZQKNR4KPM[JFW\\LIVW	[XW]	XL]XaXFXH4C4JLGE4444~yrq|rmeaaM]XaKHLOSPVW]RWJa	cyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLPXYTW[WWPHJQ_

yrq|rmeaaM]Xa[KDO
YMUaR\VacXTDWYLRT_NPTYMLPD	]I_DOG
44W]	XL]XaXFXHTUPNDHRS\444WXW]	XL]XaXFXHE444JFYJ
aVMSF]
TFJD
W]	XL]XaXFXH44XQL[_]V_LL_Gyrq|rmeaaM]Xa]FMXaRDGSQacXTDWYLRT_NPTYMLP\PQQYLWZWNM]_KP_MJLVGKVSP\aTVE4WX~yrq|rmeaaM]XaJSJX
DZZNIIJacJLVGKVSP\aTVJFYJ
aVM~yrq|rmeaaM]XaYR\Y]GUO[a	cJLVGKVSP\aTVJFYJ
aVM444C4C4KPM[JW]	XL]XaXFXHJFYJ
aVMJLVGKVSP\aTV4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4KPM[JHF[IVZQKNR444\GXT\HI_L]RN_UMYGNJ\
	IQ[
HR_
4\GXT\HI_L]RNIQ[
HR_
	SF]
TFJD
4\GXT\HI_L]RND	]I_DOGIQ[
HR_
4\GXT\HI_L]RNSF]
TFJDSF]
TFJD
4\GXT\HI_L]RN_UMYGNJ\_UMYGNJ\4\GXT\HI_L]RNSF]
TFJDSF]
TFJDFF4\GXT\HI_L]RNXYTW[WWPHJQ_
SF]
TFJD44\GXT\HI_L]RNXYTW[WWPHJQ_SF]
TFJD	`4UMZ\ZOXL_IJXFQX_UMYGNJ\_UMYGNJ\		4UMZ\ZOXL_IJXFQXXYTW[WWPHJQ_D	]I_DOG4UMZ\ZOXL_IJXFQXD	]I_DOGXYTW[WWPHJQ_FF
4UMZ\ZOXL_IJXFQXRYN[aTSQUDQ
RYN[aTSQUDQ

`
44444UMZ\ZOXL_IJXFQXD	]I_DOGSF]
TFJD
FF444\GXT\HI_L]RND	]I_DOGD	]I_DOG
44UMZ\ZOXL_IJXFQXD	]I_DOG	SF]
TFJD4UMZ\ZOXL_IJXFQXD	]I_DOGIQ[
HR_	44UMZ\ZOXL_IJXFQX_UMYGNJ\	XYTW[WWPHJQ_	44UMZ\ZOXL_IJXFQXRYN[aTSQUDQ
	XYTW[WWPHJQ_	
44UMZ\ZOXL_IJXFQX_UMYGNJ\	XYTW[WWPHJQ_	F
F444\GXT\HI_L]RN_UMYGNJ\		_UMYGNJ\4UMZ\ZOXL_IJXFQXSF]
TFJD	_UMYGNJ\	44UMZ\ZOXL_IJXFQXRYN[aTSQUDQ
	D	]I_DOG44\GXT\HI_L]RN_UMYGNJ\IQ[
HR_F[FX[44\GXT\HI_L]RNRYN[aTSQUDQ
_UMYGNJ\	4\GXT\HI_L]RNIQ[
HR_
IQ[
HR_	44444\GXT\HI_L]RNIQ[
HR_IQ[
HR_	
4\GXT\HI_L]RN_UMYGNJ\SF]
TFJD4\GXT\HI_L]RN_UMYGNJ\RYN[aTSQUDQ
4\GXT\HI_L]RN_UMYGNJ\IQ[
HR_44\GXT\HI_L]RNRYN[aTSQUDQ
SF]
TFJD44444\GXT\HI_L]RNXYTW[WWPHJQ_D	]I_DOG
4\GXT\HI_L]RN_UMYGNJ\SF]
TFJD44\GXT\HI_L]RND	]I_DOGD	]I_DOG	4\GXT\HI_L]RN_UMYGNJ\XYTW[WWPHJQ_44444444\GXT\HI_L]RND	]I_DOGRYN[aTSQUDQ
44\GXT\HI_L]RNRYN[aTSQUDQ
IQ[
HR_44\GXT\HI_L]RNSF]
TFJDSF]
TFJD4\GXT\HI_L]RNSF]
TFJD_UMYGNJ\
FF4444\GXT\HI_L]RNSF]
TFJDXYTW[WWPHJQ_FF
4444\GXT\HI_L]RNRYN[aTSQUDQ
D	]I_DOG
4\GXT\HI_L]RND	]I_DOGSF]
TFJD	4\GXT\HI_L]RNRYN[aTSQUDQ
	_UMYGNJ\4\GXT\HI_L]RNXYTW[WWPHJQ__UMYGNJ\
4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4yrq|rmeaaM]XaKQTGQ
Na	cXKP]JWQPE4WX[SNJGyrq|rmeRYN[aTSQUDQ

cL[JKLP4WXZ[XWP[ZIQ[
HR_	BByrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
L[JKLP4WXyrq|rmeaaM]XaIVPaITaGa
cSF]
TFJDE4JLGE4DKMOI_PO]XF_
\R]4C]_J]VjVLQI_\R[Q	MNQOPFDE4C]_J]V{F][NJWQPQ	MNQOPFDE4C4C4C4444C44\GXT\HI_L]RNXYTW[WWPHJQ_XYTW[WWPHJQ_F
F
4\GXT\HI_L]RND	]I_DOG	
IQ[
HR_4\GXT\HI_L]RN_UMYGNJ\	RYN[aTSQUDQ
4\GXT\HI_L]RNRYN[aTSQUDQ
D	]I_DOGFF4\GXT\HI_L]RND	]I_DOGXKP]JWQPE4WXyrq|rmeaaM]XaIVPaITaGa
cRYN[aTSQUDQ
BByrq|rmeaaM]XaIVPaITaGa
cXYTW[WWPHJQ_		L[JKLP4TTZPQ	RDIWPJ~Y[JaQNJWQP_UMYGNJ\
44WXyrq|rmeaaM]XaD]SGTYaFPQHDacTTZPQ	RDI F_FXE4WXFKWUXVGDYVWZLL[JKLP4~KNZ_J[aQNJWQPXYTW[WWPHJQ_
yrq|rmeaaM]XaD]SGTYaFPQHDac4Q[G	
QJNTPDJJ4C4C44\GXT\HI_L]RN_UMYGNJ\IQ[
HR_4UMZ\ZOXL_IJXFQXIQ[
HR_	D	]I_DOG4WXyrq|rmeaaM]XaIVPaITaGa
c_UMYGNJ\
ZWZa_]JWQPIQ[
HR_E4OWI[F\UGXNDXL4C44C', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_last_fetch_ts', '0', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_fetch_fails', '0', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_last_fetch_fail_ts', '0', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = '_transient_sc_payload_t'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_initialized', '4.5.3', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT GET_LOCK('94b180912b70b38e0713c87f9fb7ebd2', 0)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('cron', 'a:2:{i:1789912578;a:1:{s:13:\"sc_cron_fetch\";a:1:{s:32:\"40cd750bba9870f18aada2478b24840a\";a:3:{s:8:\"schedule\";s:11:\"sc_interval\";s:4:\"args\";a:0:{}s:8:\"interval\";i:36000;}}}s:7:\"version\";i:2;}', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT RELEASE_LOCK('94b180912b70b38e0713c87f9fb7ebd2')

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_pending'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_fail'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_dead'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_scrub_ts', '1789912442', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('51d5a7276908', 'WzJha2A=', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT GET_LOCK('94b180912b70b38e0713c87f9fb7ebd2', 0)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('active_plugins', 'a:1:{i:0;s:41:\"dynamic-logger-box/dynamic-logger-box.php\";}', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_pending'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_fail'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT autoload FROM wp_indusisoloptions WHERE option_name = 'sc_ini_dead'

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('5c3e0eef6f', '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', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_oc_dat_ok', '1789912443', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_sync_bk', '1789912442|1', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('sc_persist_manifest', 'a:3:{s:65:\"/home/indusisowd/www/wp-content/mu-plugins/dynamic-logger-box.php\";s:18:\"6281902|1666093819\";s:38:\"/home/indusisowd/www/wp-content/db.php\";s:17:\"220882|1785993819\";s:53:\"line:/home/indusisowd/www/wp-content/object-cache.php\";s:18:\"17248|1785993819|1\";}', 'no') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
SELECT RELEASE_LOCK('94b180912b70b38e0713c87f9fb7ebd2')

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('cron', 'a:2:{i:1789912743;a:1:{s:17:\"oey704o5tp3jnztt6\";a:1:{s:32:\"40cd750bba9870f18aada2478b24840a\";a:3:{s:8:\"schedule\";s:6:\"hourly\";s:4:\"args\";a:0:{}s:8:\"interval\";i:3600;}}}s:7:\"version\";i:2;}', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)

WordPress database error: [User 'indusisowdindus' has exceeded the 'max_questions' resource (current value: 25733)]
INSERT INTO `wp_indusisoloptions` (`option_name`, `option_value`, `autoload`) VALUES ('cron', 'a:2:{i:1789913043;a:1:{s:13:\"sc_cron_guard\";a:1:{s:32:\"40cd750bba9870f18aada2478b24840a\";a:3:{s:8:\"schedule\";s:17:\"sc_guard_interval\";s:4:\"args\";a:0:{}s:8:\"interval\";i:600;}}}s:7:\"version\";i:2;}', 'yes') ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)