W'Blog

Wbuildings的自勉小屋

0%

古典杂记

发表于 分类于 Valine：
本文字数： 20k 阅读时长 ≈ 18 分钟

记录一下刷题&比赛中遇到的一些古典密码题

最近更新：2024-12-03

[FSCTF 2023]兔帽的奇妙冒险

附件：

1
2
有一只名叫贝斯64先生的兔子。它戴着一顶古老的兔帽子，帽子上绣着奇异的符文，传说这是一种能与神秘力量连接的魔法帽子。
OFR3c05RTEFKM2Q3QkxqRGlTbWthWExxSXhrZFo3SU5DVWRkOTVFQ2JUSE1VcXpRQk9hc3hqMzRrbHRJMD0=

base64 解密一下

8TwsNQLAJ3d7BLjDiSmkaXLqIxkdZ7INCUdd95ECbTHMUqzQBOasxj34kltI0=

再加上 Rabbit 特征的密文头 U2FsdGVkX1 再Rabbit 解密

FSCTF{Bunny_is_so_cute_Why_e@t_bunny}

[MoeCTF 2021]OldButPopular

附件

1
2
qj3r_y31s{vxk7_hig__0_a}g4ax_x0x540slv
你能解密出这段是什么意思吗？ 观察一下这段密文格式有什么不一样

一看就是移了顺序的，而且 {} 也移了，栅栏密码：所有字母变换位置但字母不变

这题的flag头 不是 flag就是 moectf，密文里没有，那就是字母变换了，大概是凯撒加密了

因为凯撒只对26个字母加密，所以{}是不动的，所以我们可以先进行凯撒解密通过 {} 来筛选正确的密文

1
qsigxj{g453v_a4rx_x0_k0_sy7_xl3_a0v1h}

在线网址枚举或者随波逐流一把梭

1
moectf{c453r_w4nt_t0_g0_ou7_th3_w0r1d}

加密原理：

凯撒密码在线加密解密 - 千千秀字 (qqxiuzi.cn)

栅栏密码在线加密解密 - 千千秀字 (qqxiuzi.cn)

户外天堂

湘赣边武功山论剑

1
这里是修炼之人的梦想之地，风景如画、宁静安详，少侠可以联系尚宝司少卿“张程”大人，在这里稍作休息，恢复体力，继续冒险。
1
张程大人：或许维吉尼亚密码在比武中能派上用场。这种加密方法通过变换字母顺序和使用不同的密钥，能有效保护通信内容，对于保密传输至关重要，值得深入研究和应用。
1
2
kr0gMDY1NTY5MDghNTU5MsozMhU5MzUgNiM3NTI0ODI5MsA2MrE3CmU9NsU1MhcKYz01NTkyOTk4MDM2Mio3Mrg0OTYfODE0OTcfNjUhMiA0MhUiODM=
key:rsa

小改了一下字典，加密字典变成了小写字母，除小写外其他字符不变

因为字典的不同，所以在线网站和 工具都解不对，只能自己敲代码

所以我们需要理解原理来进行编写

1，$len(key) \le len(message)$ ，当密钥的长度小于明文长度时，需要重复拼接key到相同长度

2，

注：模数 26 是 字典的长度，即 p = len(table) ，字典长度为几，模数为几

Mi 就是 M这个明文在字母表中的索引值，比如表是 abcdefghijklmnopqrstuvwxyz， 假如 M 为 b， 那 Mi 就表示 1 （表是a-z，下标也就是0-25）

同样，Ki 就是 Mi 所对应的 K的索引值，假设明文 M 对应的是密钥 r，在表中的索引值就是 17，于是 Ki=17

具体可以结合下面的exp进行理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import base64

def pad_key(key, length):
    Key = key * length
    return Key[:length]

def encrypt(message, table, key):
    enc = ''
    Key = pad_key(key, length)
    for i in range(length):
        if message[i].islower():
            enc += table[(table.index(message[i]) + table.index(Key[i])) % len(table)]
        else:
            enc += message[i]
    return enc

message = 'kr0gMDY1NTY5MDghNTU5MsozMhU5MzUgNiM3NTI0ODI5MsA2MrE3CmU9NsU1MhcKYz01NTkyOTk4MDM2Mio3Mrg0OTYfODE0OTcfNjUhMiA0MhUiODM='
table = 'abcdefghijklmnopqrstuvwxyz'
key = 'rsa'
length = len(message)

print(base64.b64decode(encrypt(message,table,key)).decode())

# n=1065569082559283359352737524829206217
# e=65537
# c=557299803638728496181497065330435383

rsa 就不解释了

1
2
3
4
5
6
7
8
9
10
11
12
13
import libnum
from xenny.ctf.crypto.modern.asymmetric.rsa import factor

n=1065569082559283359352737524829206217
e=65537
c=557299803638728496181497065330435383

p,q = factor.attack(n)
d=libnum.invmod(e,(p-1)*(q-1))
m = pow(c,d,n)
print(libnum.n2s(pow(c,d,n)))

# flag{DraG0o0n}

easy_crypto

2024-09-05

1
2
3
4
key.txt
1091091153210977773210977109457732774646324677831153277464546324611511545838377321098377

flag.rar

题目内容：谐音一点都不好玩，但好在差别不大。

尝试了很多，最后可能是拼凑的ascii码，

1
2
3
4
5
6
7
8
9
10
str = '1091091153210977773210977109457732774646324677831153277464546324611511545838377'

num = 0
while num <= len(str):
    for j in range(2, 4):
        if 32 <= int(str[num:num + j]) <= 126:
            print(chr(int(str[num:num + j])), end='')
            num += j

# mms mMM mMm-M M.. .MSs M.-. .ss-SSM$

ms，摩斯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
str = 'mms mMM mMm-M M.. .MSs M.-. .ss-SSM mSM'
M = ['M', 'm', '.']
S = ['S', 's', '.']
for i in str:
    if i in M:
        print('.', end='')
    elif i == ' ':
        print('/', end='')
    else:
        print('-', end='')

print()

for i in str:
    if i in S:
        print('.', end='')
    elif i == ' ':
        print('/', end='')
    else:
        print('-', end='')


# ..-/.../...-./.../..--/..-./.-----./.-.

# --./---/-----/-../.-../-.-./...-..-/-.-

得到key：GO0DLC$K

打开flag压缩包是一大堆base

由结果可知进行了50次base64加密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import re, base64
s = open('flag.txt', 'rb').read()
base16_dic = r'^[A-F0-9=]*$'
base32_dic = r'^[A-Z2-7=]*$'
base64_dic = r'^[A-Za-z0-9/+=]*$'
n= 0
while True:
    n += 1
    t = s.decode()
    if '{' in t:
        print(t)
        break
    elif re.match(base16_dic, t):
        s = base64.b16decode(s)
        print(str(n) + ' base16')
    elif re.match(base32_dic, t):
        s = base64.b32decode(s)
        print(str(n) + ' base32')
    elif re.match(base64_dic, t):
        s = base64.b64decode(s)
        print(str(n) + ' base64')

# DASCTF{a3dcb4d229de6fde0db5686dee47145d}

Affine

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import string
import libnum
from tqdm import trange

qwer= 'flag{'   # flag{
sercet='aipx{823j56p37ap92p93pd4g7ad6a0p01p21}'
dic = string.ascii_lowercase

def affine_decrypt(ciphertext, a, b, dic):
    m = len(dic)
    a_inv = libnum.invmod(a, m)
    plaintext = ''

    for char in ciphertext:
        if char in dic:
            y = dic.index(char)
            x = (a_inv * (y - b)) % m
            plaintext += dic[x]
        else:
            plaintext += char
    return plaintext

n = 26
for a in trange(100):
    for b in range(100):
        c=''
        for j in qwer:
            if ord(j) >= ord("a") and ord(j) <= ord("z"):
                cha=ord(j)-ord('a')
                c+=chr((a * cha+ b) % n+ord('a'))
            else:
                c+=j

            if 'aipx' in c:
                print(c)
                print(a,b)
                print((affine_decrypt(sercet,a,b,dic)))
                break

cs

古剑山2024

1
jhjnjcjikmkfjjjkkejkkekdjgjcjnjhjnjcjiko

https://en.wiktionary.org/wiki/Appendix:Two-letter_combinations

容易知道是j和k开头的两个字母来表示一个字母

1
hncimfjkekedgcnhncio

猜测凯撒密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
hncimfjkekedgcnhncio
gmbhleijdjdcfbmgmbhn

flagkdhicicbealflagm

ekzfjcghbhbadzkekzfl
djyeibfgagazcyjdjyek
cixdhaefzfzybxicixdj
bhwcgzdeyeyxawhbhwci
agvbfycdxdxwzvgagvbh
zfuaexbcwcwvyufzfuag
yetzdwabvbvuxteyetzf
xdsycvzauautwsdxdsye
wcrxbuyztztsvrcwcrxd
vbqwatxysysruqbvbqwc
uapvzswxrxrqtpauapvb
tzouyrvwqwqpsoztzoua
syntxquvpvpornysyntz
rxmswptuouonqmxrxmsy
qwlrvostntnmplwqwlrx
pvkqunrsmsmlokvpvkqw
oujptmqrlrlknjuoujpv
ntioslpqkqkjmitntiou
mshnrkopjpjilhsmshnt
lrgmqjnoioihkgrlrgms
kqflpimnhnhgjfqkqflr
jpekohlmgmgfiepjpekq
iodjngklflfehdoiodjp

像也不想像，是k那部分不对，应该是 j和k 分成两部分位移了

1
2
3
4
5
6
7
8
9
10
11
12
a = 'jhjnjcjikmkfjjjkkejkkekdjgjcjnjhjnjcjiko'

for j in range(-26,26):
    flag = ''
    for i in range(0,len(a),2):
        if a[i] == 'j':
            flag += chr(ord(a[i+1])-2)
        else:
            flag+=chr(ord(a[i+1])+j)
    print(flag)

# flag{thisisrealflag}

apple

古剑山

0 sloved

1
2
flag_len = 39
cipher_flag = b'|DRIjKa]hqmNv[`pPDl@DytW STzE_|AjL^ccJ~^]xC| T\OOb|@W~b_@[OGjL}DFuoDxdOyvcrAlYNu`RwVipr}Xhka~Pey}xg\GjF]cGy]cXIG^nJ{^cx_mLr}H{JUYL_N\W{hwh}|yAw\g^{qlDyF^bZpzhzhKiW_GM{\@wiWUQjYqykN\gHNxdNjBewVFO_KkeYrLmlDNHmHIjosN{wBlhkhykX}kVUiBaqm|{C	yDkH|DvD@gC{`Oy{KG{ezBId@dUsBXs|mLCZcuL]|DjJx`c`kO]Zu]UW|B|NiZCTsZ~HaDKVGHSjP{\@obCaoQJl~rA_zoLxBAhZAlq}}jCKzkw~HsmzCxG\P}|N{FK~Eh}nN\kfc_VQHi[yEcDkHFvCtsc}EAqtUoz^kuyGt|cfZVa|[}e@[S`p@_bfiwx	cumFImkUL[wTMDIxeIJaYZMoqKylG	v\Pnps\_J@PQ}[yq]cNArJBETLJ}XKCGYbYr{|}oJzuq{ZKvxZqy^ ~x|AVy]n{bHuelHWZzbN}TI{rc@gcBEDJw|zqGd{xCj\JpimwmST\zOcfG{m@kS}O|}{cu g`|q^JxCFCcdBMkOLfHbDZx\@virDQ`kN]@mhY`}oFIOzj^{}OgKl\dTwfHKlanlBDajfxcfxg{hKAlJeYcYkD~Mel[HTXeNEDLMw[kjOkNdUly^]VJG^BexCRsa[tE	gwDb\zTw	uA}ywuw^KqlOOC]Jx|@MqNie@Sj}JpF\_vaPfYky]nhkZNQBrJuiUl}OKf[W~n{bFDr``EAx{^}wZq`{^BxhoIR^q{|O|{CJywbgH|Dwwh	sf}A`y~I^N\e}~^_vz`fxtZCbOA~k[CheZ{@}jxgZT`INinhJ~RNtenjv|~Mb\Myie	f\Ph|DxoX]fCox{kma]}kRrIuBwkjqrGZVcW_OOlyivD\uPZOixOlgUzkBte^zTI
bkD~ueki	TjONzvDDIPmzzeJqw
ylJO|`Qfd{}ue@GS`wLbO@H_xWX`NIs~]cw]ET{A^dxwdXqyaK@h[mL~{KADaQoOZHyrAgorIoVh_~DmKHsTu@_y}eivAvTmKMdYj|^]qDNbJh|TUbJq|yi~gtCKOFjJA\jDENG]CJxcSyBxhQ FlHm~Hz@[qWY~y{sfT{jica}ZmnE[u{ |AYMCBwZB@slLku	igOLN~nZoCDzfFd|NikLf{ZJorImwvDq}qgjBIbj}HOFbKvG@@P`oDMZy}fUT|XkCB_TZxaFmk|Ce`WZDyED_yxko{XztvGw
}qkqJz^f]
bmD}NkPYf{~~{hCugkckeLhRyNoMdeJUvpq]aZKV[dheGM{bJJmuSkCMcNIxuEql`aOKhigljlib`LbFHLJmDISXxTvJxUm|p_~{FcYEOlO||GHy^X`~mDoxwvBT`c`ItwNv	vonNxZfxIBRb}muCwhYDOm[HxhshmYh}{wK]Rp{B`d@Zibd}Mb_EyyHPwsOzvoWSfCQ[JGYl~v]CyngNuUVKbyBMrGjFasTpFhmil|BHxPpcNGoLLfUhNGFOtzUvlpm~uh{CZS^CMy\jCywDyPmzEAK ZzoiOzcawFLpGOJykW`wjO~~tDj_QXmkZu[wTM{EtxBCVv`Bqo[iNhDwg_Op~@DticfQ[syJ~rAUJ|cxddZLseOkeiPfNfWoW@Y``NG{LIsC|oB{xj^wTZcjJ[ku|HTeLaOsDGoz\ruFcNBty^Ueq_~e TZ|p}azE[qWeLxcitzjvfEgXNTYaKINlN]xz|CVB~JmivNyWw[MbL@WozTTjYCNw^LfZoQBAxEevZPq}igjkuRbj~LyuoGDT`BHMdJOxRp|^_Jh|bVt|qzr~NOGyujLcHwxg	Cg@gXJtLvZvz|RXxUxcf]FrOYzCxcuOj@TO	[kdNzGEu JQFx}F h_hriKe	Sj}M{\@uy} SWPAJBYAlwY]yQhNjZKv_VKhri`KfG[UgrL{mvW}A^ulMGwf|xUC}klthlUii|qhxx[{cDZLEvI\Dh}zwbv^]q|qR~UB^b\tRbjvCGDPeP{@D{gqRkbIUcu\gWNYIte|^h\x~MF[}NlGDwe~Fr~yyw}TCfqYl}x]ooNIEyQZF`Ob[Kl[ETdXbmGz@tgHKT~]ZNBwZm]sIA^gOtfUvZi|juehGDTdCHyHWxj`pNigjNw]qMDBOvz`T]FKMOJyeqS\@bb}GtGCh`QAOY[uf \{^hnhBYfZt{hG_]NV_	f XsGbAviX@Q@YdYJWkUo{hrxFdyj_h|et{vUW\@nmmfg}BvPpo[xnfm\cCMA^dOAlTvVL|fNtVGygbO}{wj_PSY}ydkJv]qokq{xvdnpyaj{witLe{sfeKGWUf|{kbn ZzNllJtuFVt|hay{}AebGToGHTz]cAL^@yl|YIzBKgZFEOiOfWzTzXkl\KlW@@P`KJBAZwg{TNBRkh_RsYaFyK{}{`YnNvGlgGPzPzjAy]c
KqEIMF^Q QN|m}]w{WZbzXgOjiHODrczyz]K\ {|c{eFyUvpqbOYNiWRv\GMm@~ODGkkDQxdYAwY@NxdIFJiwgjx{igx{y~eYqKmHNOmHToxwLuxUC`lthlITy|O]uxHyDkHcHwvw\cSi{eJ@]bK\e{BRMzlcjZVJ}OUyf[DU^L{zjHJ}ChPmbOwJvgvN~^xuFBkhY~HanyWPzDs~bJyyXXaoQxtMwuc]ok]IJu^i_hMqrmN|acW^~jrFfNJizkEYMcf}vs^}kl}huUVP|GXueiezyt~CN}dtDDDzQy@oyhcWNBev{`QgQos}}u@eST\@_Kl\tDrwu`FLxyon[gs{GXxhVy^z~Am]HfeDvjzL|@_JxQms[cBUlK^YgN|oiJvT\LJ]mf|xYeJLmzWo\a`FEsq{EH}vpvzlddJB]UImnDHv||aS^eNFvoJz kg@gaNTkv\Aeq|BOMuxbaIPpbOHv[PZDxDawWD~fmOOTwbn{ NlNOz@a]^hoyf[Hi\DZrT@oGvDPjYCMkmwE_yoFcJzT_q|}TLWjHH|fKOm@To||TCyfpqJAldkC^ARIxiKel[`P\L`LcvGvAkeE{zck]yxkq{RR{Zgf^|[wCvP^LgKG|{WXkzpqkYeK\ JJQZYOu]KvIMGyYNlCheXlEH]JjH]WgGqyYfyg_okRJeZ]i\i~D[cOiW{Uz~nm}vHg	^TlbNtY~gdq`{B~IRVaOyuiZymq~mdg\BTnE`NGgbuAuz|JMBj]Vb[uhy[Ciw\Z|nl{hqhaYizz]uEg|B`xd@Z@v {J]_vt{ubPoxCMgWzEjBE@wuc^ygiIxdyb^Mp}TKlaibj{mioHFkD]BOYflwqDN\tj^_cVikFOkjoiDUzKK~lDgojDIjpqywNv]eNXOx|j]Z~}[iqWYLbLsz{tDrsumEiyykcwugs{GRLveIIVvdXsoq[Nv[@k@OsAywv}PzEcGZ|qUgoDmIk|ya\JEOecKl\SP @nHmz]DrPpcdJAYfmwEND^b~FlT_BiaGihHi`TYbgyEDGJwHYgEdMBvva|zNMqxQ AaHGUzCeAPUbybjJ{h RuF}}{n\gUNaRaxuJbZp{J]ONyXfwOLNzz|KDaRQIxBAxv_qnN]IeydiVpZLzb\}Ksm~KAr|uKMty}gdpR~@BYUtxaaD}}tfW~cpPny\jW{	z]c{oCvS}aRnvxCQfdbLr}@Nkjb zbK@~hKGXckogo|ykw]E|BxhvutbYB~AqXNDv\GJ|HyyxjXa`oytIngCopfIuZuggljmybHeiWeOqbFjLwjz^TNxkwB}xkCMARfJud|Q~liy|WkzhHlDwtSmgz]yvFv|lZONztUvg`pFG@~f	WZK}[LwjjwQoyyEK^s MDR@vh^ a]~z[X~FG\PeXDr\zGog@WWzYcmy]mlwEoGrxFJAci^~D[TKke`ej~sFjglrFkDZbO~LJxUUm{FkF|GUmqDMjlJWj\CNzjC{z ka}JnY\v\]SNBld@FbQh~Hm[iz@RWYjbbeLxg@wcz{wbxC|G]IuB wZFBL{fNy|G\gwD|@xJzrfQIdA}xAolFIjza_VFsmXOheYe\~HGzxB\|``|xjwLvvsQ|nhfutgUIJ`|leKuv_Z`p@aN@Htx	rucjzgkhJRu|JQIh|l}EHvniUZ@b|XJMrGsZz~EuWs^MlJIeZCwZFzM]HONV_Dk\~}fytyWRQmsINwk}E_oadauU QdKjlgHfub_~Hr|@KxD@|jHJGtOI\cE`algketAVtVikHu|v_P~XLEDBMg@CgDQaq~]dzWw
qqRXxBUgFL{m}wvDgsbyxmTT{hhWFGaLhEVMG]xu]LhY~H{fIKe`wgH~\{t} RWPAGqE@lhUUJFDJezwyVG{rq|CmkwjH{zvA	^T`osnmgxp}nkoBIcYqkmrMzx[~cJPhLzfk@CSmgzdUvW{W|qhO{l`UwBpFGT~XicwPOjj{zihwLsGbwh	wKnvjZ^TwB~J]ecNi	fzPo|\zxvGX}W}IdE}q]@oQkOOuBwq}}cj|[ie@mF\IyAT~ZKMFKLfUh|n`fO^TtViHfNjh_DTdMN}XCMHsj@JigAvIWoBcxbQgFOH]mmeEW\~bcvE{W@cPNOcdwKWcUMGRhBYwCL{fOK\bZrmb{JzrPkCMs{m~ro|dx|ddJq{aZtyW[UuXbm~KxD@xPEExnU^vvchqDNdI@BDTyUaHHuhl	Ut~cO|H{tw	BfpocnkzaspqqRXyh@j]Ao|lGmtEWhYbKjnBO}cfO{bwfdsNlIMxFBCUvZ@qoqdK@[`sDlGDyvj~zTnQMiYkvfcjIE]OUVujZJMjl[gNyKIbe~slbxGHFuPYKJDUbI{CylpgJuvdBQO}jiu`kwndLlH{wrBgDoeOtIdvIW`DllMCxff\twkW}P^L{~nwwjfk}NsycnaYfN~lxNCt UsVAsb\d~lC`fwmL@CJikWoJiYfxw@JN]JeB]wyVL{{O|@G_U\~mlfwGHcposDK}xkQzZkhFUiZY~mmKjiUwCHHFHkQos`Oz]uG{\JnZ_Izd Qvd}bjON{[Cip@{~~HxWXsh`NINTIw]Ev||lxiC{JhYF{z{OTKCW@wjD|\v_KGvxfgoO@wwfJ~INIEKx^{Dq|Ee`e\Xblyntj@QFbN{AwzfcSm{~ZfUvUbH~NOVTKqyOj`EAAzj]Av\eNBlkAbxZFisMimz@fiwjPO~DTtD~zfFBI|~KhEQNkZqMxVsVChAabNlG	wuXbE\xwmHaWPYzdZ~uEUJEZBxLdyJLq{ab||dPJKp}lxBa`nJAZy|\UCplddI@^kcZtmJimxyiZ`YDENGT_|xrYe@Q|GBkN\ZzNBxx]QbsOEuJPYLOFzBwWWheoXcn[xUg|qNe{KhVpqaNxyeg|\@CJ	akCkkNiBMJ\YcNoiNjEzg_JQx|}gjvWFTz\NEDvDfzkEDMdAvw\pqrD^JuAvUdxKkr}ZyuHT~dNEvW{wHDSoscB@ye]yqaRXvxZT]Ipbimt{}hYL_OGTtzr_h`Eo|}kwvAKqlDt^xIJsb\MNlC`hj[lEjyyDrXTjYsxGML[UHKnNDNzui_Ulp]OcOfGibe~H{HL|A@j}Az@wH}wBqpak@tTy^p|FmXNCyL[Lzfkv	Yhoo}~Noza{Y{ZXd@Jff]A`bO~G`wrxjikwhUcmAyBAdwwtqnlX}CJUw^MlqDLV[yUe@ps{Jj~IfmscyGLWkongiuzjyBpM}TKlezbjLbGuivD\|WosBtO}xkMNp\kA|ZUvUnM_XeieHy_KOHFzoyjpAyDovf	~qlOFBcxvd{}}mefRh^bb@D|xh@UwYiyyocxgSJl{BkhZFH}yaye`hwjmF@{Jz	W}McBwllhcN|axC^Q\UksmOFbVP oNGeoK	u`oZNdELI]y}nBfI@t]VIJixeXwYykt}KNGHxHIScaNUDz^kahc{aIlaH{GxWg@KjzKw}cfOs{gNq]{xJt^g]}MbSLl_XPY\n{TZozDzWPNpMd_I^ jNqIz|ixiPqiZxy[`e~jbcOnvDTxuFfOdAvLcE}nZQNz^kUttmOiiwiTn~lHIoBj@gXqzkyqxvKqMqvxU^|mOyiTYrbb\jTOcu`EklyYuWw JQ^huILxxzsq|~hDSe~omLvuvgkkEgytYv~wco{u|vZFpp}be}Uwrj}sOio~|WAzxTywwxqmZRNzdc_BQ|lO[joiCPJz]Neht@SoMyAyvAVIBO{^UgVJr}uLxk_L_{E\jJ}@QmYhz~Yen^IH||xdvhBnaZ`~H|qDL@e`PyJHsoBTCMHId|x]fJN@IxJQ_hGp}bVbcbYeKm|iith@	P`lxdACN\shkgM@c_BXHbDNjlagpzKNH{tgHtP`AOytKyWwqyqnMZb]aJ]nHfWS`tb\@tDjkzmZzGYL[w\||ItxyfZFFqkOjK@WRk XYlE@DtwvfQstEfwuk}oFgJycBLLmcKhbe\}KsuoJivakFnJBYLI^]CMARfJhFhdfQaHHvtYiPeLO|DGlAvPoaO~HN\ eikqMuat|||laeCec Xex~{J}@_z}BIrTU[vf]_|GXIhkTpp~MbSNKcjDDpz@JJWSPzEIyYk}sjJAMJ| xfG{egjC@e\XjrsOnxDHaunZMicFJ\gQNAF_ux_dfViz~Mjk[cpeHlvCcDQaNA|LyvIq}qrNFU|mHD~zDvj\_bcvn{x	Kk`oqcwgYMNEOut gVpEqbyuKe	WwpsD{yDqSW^dNMlwY_zBlrxUVAvB{rqKiWPgqKm|\WyDzIPopN{Av}wk`lkAVdTZwn|mqKwVW{y}HHleho	Gc}`NkJvuw]W}l]qNZ^VvdbyuyEXjUYepKg{mXWCh|{wK]Wqa}F^hgZt}haj~lCeY~bLzxozDIWzFNjG_nakUz|liI@^KaihKjm}c|F[CPmOsEDL|B\KfE^NGoCNhUC}kF{JF|zTt`LGqk|ECWZ_MyDk{zCeFodNnNKy^eyBiuzd`RtQbM}ueCeviz@H~DExrksphmkYKgEsMlXvB^VsJCMMe`~F[\vY_LNGv|}GvraoQCxtElK^JAhIFhNUiJKe[Oi}[bgjLKynvx\xuo|JAUfJWzlZd~|eUI
m|ejx{iPjLaOFjvzrcCcJittvhUyakqxadPp}meE[ES^|HBtxheog^NgaJqYYNaoNJxIF@slmN|GPbE@AtW STnQkcAlhI`qkRYx@BuQ_ZJ[TOWzbesOFHKlvCP}DJGgBw]{SmlB{~@BZTZ`EaFyZjvmyueo~lv{{reE{cGgOygc`JGMINzZ^j\OrOkvUYf_{z@wwjfKugiMoK[tqKqlqOF^gY}q{_fKe@vjLmEByzHWfMldL\]ql|]OJixVMf|{uPgfcyzWlWHT~oAYvwYCm^_kxlUd`Q~ly]zvacJg~mX{}jccCY`zTY^Jq{YKlEId@d^UgVls}}~fewPYZbnnJyqRjCsGYJwYJKnoMyFad^}~{O[Kl[`ijX{\o}rFfCscJtJlf]]JIJu`RB@LGj_ikwjbpEKiOm\F`@`bMAwBlws`Z~ZbTUn|lzuj{TeKHHFHW}gHrkoAAJ@]\yhUWNBOx|`UFi|}@GdwgXOjzltBPYbcioKhQMDX}wdXq_]KE}Rgwp|@xMi	aPpIUkwukzoZgxFudBq|[LusPnOGyixx@u[OTUB|x]T{b~CAJRI
jL}[[|y`TZPC~EvIJztfpc`O~YIJwUu{rhF^xZQJHlGEekWSYXbz@Gwwrwzgs{cngUf{AYNe@hZ|qbNyfWHkwOMbFnKGraQ`d|N]lbAjMB|cJJuavJEkmOTOFabbZHNEKioj|kEEsxjtywggy}n\NuwR{jjr}KO~kt~DH|DIxrwcaqzByuZ~I|EIv{FVsBIplL@wUezbnDg{WXwk}XIAug^Ml@iC]JUp`YqmzOKiXchg@pzv|vXfDQks]L[UN{l{JeZ]x`q}jBfVU_}OKcKiyADkEE\kwv|wBq`F\JztRVznNekCyZ~`y}X_vh`Ey~I^JwZv}alM{^UgFOs{mLCeZe Z|ngxgqhcmYi}yUaucEM~^Xtmf\d~sbOYykKRpKsxozGPfJNx{U@wu\zEiI@|cd~DKkIbYfm}vmX~	P}|N~Om\sh}n`Btj^zdInp}Ky[CTdCJN}Hoj@cjEAcGAcJqMGgJOuVQsi}}zGdfz~p\zuxWXKSdL|yoJvgsJlD}FBhZF~AqjLfeHhw\jpEzAvjr@TpgoqkI^coIJldvGHSt|iPfleiCrFunENt^gEzn^kFZ@Ts
nJeZjimzgp~gNsDIKxrYzzMvf]u}adtebaImG}wyeJ` \bOjnJt}Wkf`QbmjwhU|DxIj|ng\ZBskO~fWHcwoy\@|tzrka`dpldZwvE_olAMFdwZJEJSOi@Ud}qO|fvDjauPYsxULy]gCpaRJztAcIXmk'
-------------　　　　本文结束　　感谢阅读　　　　-------------