From 44c6b994e53f516f37d68d0f4a10f7dcaa808ad8 Mon Sep 17 00:00:00 2001 From: felixm Date: Sun, 3 Dec 2023 18:20:02 -0500 Subject: [PATCH] Do day 3. --- README.md | 3 +- d3.py | 43 ++++++-- i3.txt | 300 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 336 insertions(+), 10 deletions(-) create mode 100644 i3.txt diff --git a/README.md b/README.md index 092f444..f06ffdf 100644 --- a/README.md +++ b/README.md @@ -2,4 +2,5 @@ - Day 1: 7:52 ... so slow brah :/ top 100 required 2:05... - Day 2: 22:30 ... I mistyped the first and second was just bad top 100 would have been 6:16 (doable?) -- Day 3: +- Day 3: 13:08 actually decent but top 100 required 5:24 +- Day 4: diff --git a/d3.py b/d3.py index 3ff9621..a9fe40b 100644 --- a/d3.py +++ b/d3.py @@ -1,40 +1,65 @@ -import re +from string import ascii_lowercase, ascii_uppercase EXAMPLE = """ - +vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw """ + +def let_to_score(cin): + d = {} + for i, c in enumerate(ascii_lowercase): + d[c] = i + 1 + for i, c in enumerate(ascii_uppercase): + d[c] = i + 27 + return d[cin] + def clean(text: str) -> list[str]: return list(filter(lambda l: l.strip() != "", text.splitlines())) def solve(lines: list[str]): s = 0 for (i, line) in enumerate(lines): - print(i, line) + half = len(line) // 2 + a, b = line[:half], line[half:] + a = set(a) + b = set(b) + z = a.intersection(b) + l = list(z)[0] + score = let_to_score(l) + s += score + # 8:42 return s +def get_score(l): + s = 0 + s = set(l[0]).intersection(set(l[1])).intersection(set(l[2])) + s = list(s)[0] + return let_to_score(s) + def solve2(lines: list[str]): s = 0 - for (i, line) in enumerate(lines): - print(i, line) + for i in range(0, len(lines), 3): + s += get_score(lines[i:i+3]) return s def main(): example = clean(EXAMPLE) print("Example 1:", solve(example)) - return data = clean(open("i3.txt").read()) print("Solution 1:", solve(data)) - return example = clean(EXAMPLE) print("Example 2:", solve2(example)) - return data = clean(open("i3.txt").read()) print("Solution 2:", solve2(data)) - return + # 13:08 if __name__ == "__main__": main() diff --git a/i3.txt b/i3.txt new file mode 100644 index 0000000..6cef3e4 --- /dev/null +++ b/i3.txt @@ -0,0 +1,300 @@ +LLBPGtltrGPBMMsLcLMMVMpVRhhfCDTwRwRdTfwDllRRRDhC +gNFJHJFgtZFJjZJHNNFWZWZwwDjCwSDhfCDbdwjfwDTTDT +gmQNZnZNHWnqmQpLtVLMBsPpBqrL +HlHldQtHlctzppdQtjdczHhJRnnhGNVmVRJmVjCVFCNh +LgWNgggZJZGFhCZr +DbqPswwMvDPqzlBNHtzfHdwd +tJgtJwwCtNvPHHPtHzDsdRTsBRDDWgWTgT +QhLQjLGjZQFlFZmnmGLDrzWfRldrTrzTBRWTzs +bFFmFZjhSFHvBCvCvJpb +MSGcvnvMGMJgWJDpdndZwBnppfCp +VPVfQQVbshZNZwdNDwNs +LtLbjmQRLmVhQtTbfgWjJgFFcrqqrGSqWg +fHfCNCwwHfGhcntntrrgHrQnrn +FVqpSpbPpjSVMjqvVmVvMzlzwJnbtnnlzQQlrWzJgt +PTqqRRPSRSmqSpPpSpRZwGCLGscCNLZZZTNdNZ +pQQQslVSVzzCQnZSlplzbLcHZHcrrrbZqFbZjbFm +gWtvPgdMDDtFDHHjJJbbccbrLW +MhNvwwDfDfdtvRQnpFNNTlSRSn +ZTnSnTTzqvFmVzvWWm +ClpCgltHNrtgsHdpLCHtDCNLVvQvVwVmwcsWQGMMQvcGcFcv +JmrgCHCNJtlmHmNhnJjnnnjJhPfhSJ +BgRRZTgHHvRTRmRNLNNhQWlmGFfJlWlhsQshpF +qPqSSttwnnzqqqwtVrPwMthFsJllJJlGhpJhWJQlhVQd +MjMwScnDPzcwjtqDtztnctrvgNZTTvCvLgvQbLbvjTBvBg +SWQSbbqTTbPcfMZSwZZwwn +dghjghmNDmGsGgdnfmtMRCLCCRncfc +pJDJNdsNMMhpssgdprBTBzWlpBWlllWb +TwNLNZTwWCWLwWCSTZSLzWHGrDHHPmGdDHvndGdNfvMm +BgpjtpgjBjVbRjQRhVsDnvgGgPnGdrmvnMDfrf +rhRjRssQJplRtVbpthblbbLSLzFCJZFqLLFWCzqcqzLL +PBrdPMtBPvCQBVBjCfWPqSHbszhGGnsfSG +JpmDwJgWJgNzmShhmfSGzh +pRwNcNpFZNZRWgcNplpjVCMVjdvdMQtCMLZjMZ +lDrcnnlLqLRcDDZRLjFVTHzGCLGVPzGPVWGB +pNwHpdmsNJsbpwsbzJTCPWTVFzzQTWCQ +vbhswdtdwfdsmtNSssHwvllvMcZjnjcnZqlgMDZglM +GVVtJGtzVFsVsDTH +mQRgcBRmRLnBjrtFjCCrHmFF +gqpBnlRpgZcvdSdlMdSvMt +tMSCNGSflffNhnnGqlPPsrzWPrTrVpWr +bZHbmDBQmbDZQdbDcRFZZBTTWWWwqVzszWjrFPVwrzqq +HQBLHmQVQLDdCggMfgMNLvNG +HHNDzNJPJPmdPcNGGGhnhwnVhCQBwBjQ +bsSbLfrLtRSLRSRRRsBwhCpfpCzlwCBVjlCV +zvvsvqLtZqLtzRsqTrggRMHJNWJgHHHNJcgWNPdHcH +qgbNvqbgmmZgZLvZqgnZzlpzpzHtVPzttGPrrnnl +jwswGjQDMsQMjdBwdcjCHVtcPVpCVCrPlVSrpc +GsFWBfhGBfDFDFWqNbLNqbgvqbbvfN +HgwWqtcqHNWgnHcNNCfvJCCJJfJGvnPfrR +sbDhZSmdBbsSdmSDdrjjffRvdjPrprCd +vvZbSFFlFHtqFqqWNc +ZRjnbRsHlncZGjTRTfFVSQBQppQvvFBHpF +zrLwMdhDhqJJttDQSldQVPQSlSfPlV +hCWWCzqWnmcZlRRW +HfgfQflHjWgRQRdRBWVsnbvvscbbbwvmbHncSc +tJGLtPPGZPwVvSSPhw +CLGTLZqJtMGqLDFFDZZJFZJpWjRpVNRWpllDpjlBfgVjlp +rhhGZZhLNhPmfJqvfLlq +dHRTHRHQQWcTCRTHmmjJgfqqlGmgWgql +CCwRzTRRdCCRSQwzRcppprZtrMhGBMZMnDSt +WfffvnSnfSBshwsjhlvGlh +ZHpFNTmppVmNzVVmmFMZzbwwjHGrGlPhCGrljbgHsg +pLZMmqVsZVMMVVscDfdtSSStqcRRdn +RhRbLzRLHLCPmzznHLbzCRTJhdTVSJJVSjdFFNFFNTJv +MGgMfpMsBgpnMtGfnfwBtDBjFVdNSSSFdvJSQSpTJdJjNv +lMsBgDMsblmRblnz +ClNcJZttLfLvvRQzQWwRQN +hrpMdqMspsrGDdMphhdMMMMHBmRWmSVrRVzVTzQBQvSmzVWV +ppHDMGhMMDbGMdDMGbgFbgbMlJJnjjZtZfLPcfcngZfPPfCR +ZRslLRgCclZLZzQghQhfrbfGbJ +pVSHpBBBBDVDqDBldVzfrMzQbfSTSJrzzJrJ +DqqHnBDlpNDVVnpnjtDtNjCvFLcsFFPZRcPsNNmPcFcP +LmLWSmSRNdcpcRHFHrWzWHbMbwZlZlPSbTjlwPbTPJTf +DttBsvhnhqvGGBhGtBVNBVqJlPwslMMPJwTjZbbZPTfbPs +CDthQvVNVFCHHWCFdr +RRtCWSzQZdRMrtRWrSztMggcGDfQTcfFTGqTLgGDLc +bnVhnvPHhhdJJBTLDGcDTcBvvD +pmbnhmPPmHwdCjmdrRtCdj +lTPzwhzmHpTvrDCDHJnsNN +tdgtbMMBbWdFbtqJCnsrqnMMDsrq +FjWdtgLSWttWtLSWtDWBjGGmwGlzTRwPTQGhlQQm +wcbnTtTppNLrntznTBBccCGrVldRrZqdqRCZdFZCVZ +JfHDgjgPPfRRgRlLRddR +jhDhhLMfmJjMjDbNSTzbbbtmttmN +CfGlvzpvpTjzzCWjvDlfvbbJbCRSdSRhsSQCMhdbhR +wqrSmrLHHNcLqrrLBNsndssnnhPshnsQwbnJ +NtcmBLcNVDWzjSvWtv +vZPCSCvCJffvVvmCmPqCSlDSscczHDRcwcHzRlRHHs +LFGFNnGrdQttNMFpzpMRRDslsJwsJH +gjtLnFBJrLvhZvCbZhqB +DBcjVFjDhQMSJVZbHZbl +nfmsqppnLfTnfmMmzppwgllSrbSHHtllqbtSwZ +TRzTnfRWnfdzWssfnRfRpncQPBhdDjjDCPcMQcCBGPPj +NSjWCHjNHjpPWPpSFWdtqBMBBFVBvqvJGJwqBt +gQllgDrnhQQDGRshRsZfVtVMRqwMtccVJcBtvRqw +DQrzrDzhQgrsZLrZjWSSHNTWCjjNGTLH +CgdcCFcbTbBzPgmNRmpptP +rsZtsvVvHZZzPmqVNPzNmV +HZjrwrjnjtHSHwDGdFhCdhWWJnWchCFJ +RMTqQMRJqPtBtGBPtWjN +ssHfSfShCwwbhsbHhhsmSfhSGNpCpNCjBBBLptcGtpzBBBWW +HnwrSFwffHsFwrSSjfHglJJlTgZdFdgZRZTDDM +pDLDWlDSlJDmzSJnDScRPLGGvqFqLPccGLgv +CZHfwNMVNjsHNNqPgcbcBbRQGQ +dCffZCjVCdCHHTmnlSgTlTSrlStp +bFtlLCvLlVjpCGPJndrrMMCDDCnrMg +hRsTwcZcBjZRJrfMDnsHrJnH +mNZqcTSSBTScNzVQFtGtjpFtjmGG +bjHdLrHjRWpDCtLzhzps +lZcGfTvQcQfvlqqcNCcBvVwtGzmzthmwmpthMDmswgMt +NcqflNQTBTTvvQSvqSVvQJbHPHbHCRJdndJPSHjWHb +CVmRncrRVrhcmsBgfmtfdJsJmt +bZHvZZDJwpWtdZgtGNGd +vSbwHDMFMJqPQqQvvSPQqpSwjRcTVTLjLRhVCLFLjLFnFzCC +mtffsmBwfwBDBmmsLsHqtpftGrMVMPSMPsVvhNvFrGPMvjNV +TQTQCRWjJcdcQQSPrhhPSvVGPF +cTRJCnldWJZlTgbWgbdbpqfqmppjmtljpqzmjpLw +NNPmrmPWmrSSNNPmnglghmCvLCCflh +LFbsDQMQFtQFHbQHqhvnngCftpcllptJgJ +bDjsGqLLdRVjPZPP +tgrbBQlbtRblwtRGrbCNswDDCsvFszpssCss +SJVMhSZfHvpdhphN +SMLpWZSSZMjfgGBgRtbQgljQ +HsHHNDDHzHDDjsVBBZqtWBrSNcPwQvccvvdhPclSrQSc +fGCFCgpgTfnTmgTFLFgccclhwQhwrzSwSwrCrr +pmLJGfMRpFmfFMzmgGmRpgmVqWJDqZqqHtjBBVDBBqqssJ +mBTfcfCCmpBCCSzNQScQSTfddhdtwgttjghNwGtGdgwGtd +HvvqbvMLnFZVVPjJGRGzGRjZtwgw +VFHFbsFHHSmzQBmsmT +ZNmZCmNHHzzmPPzlbplvhbQh +GDSwldfdvggPfLvQ +ddqrtlnJDJlnjScRmMRCFHTHtFZF +FPvglHSPcpNcFNSHFHNvZjdmbwdbzZtzsHDzbsbj +MMnBLCCWBJCnrCVWCBstTZdZmdTtbDLswTtZ +BMDnRCrnGhPPSgcgpG +nsbgpbdrjMdGqnNRRWWRww +tZZhPzCJhsJBtJPllJBCtCvwwcwwWLvWvwWRThcGcqLq +mlBmZQPZmlppbgMmfssg +RFdZTHFCdvjhgGnFqj +zQLtNQpzNNtNpDtDPWLNMmGfBcjgjlgjhBnvcfnBvfjp +PtmLsPzQVWzWDswCSwHbRZsGZw +nPsfnPsFhTGjqGnmQppG +RZhBbNwbBRZHZSCCHQqSpCpqqm +VMbgNWRWMDfhtFJT +RWhRPDhBHZWgZghRZwZgGJPGdncFdLcdLCjscFcjCjNLLj +mQfSrlfTVqmSVTTTrprfFLqcdLHsLHFnvsFFqnNd +TtQmVHmMrbMWRggRPJZP +TTlCTVTdcpBlcchF +ZLhwSMZhqhtqwqLjFcBvFmvvssGBmmjj +LwSMRtqMHnqhhRZRRtJSVTgggVPdTdrVbQDJgTPW +CGFFWFFVgjfzgVfcJCcgTCcBBWqSqMMBMBShhwMLMwSSMq +fmQnflldltBZqlwqNZpB +dvtnvmtRtsPbzCfTHjHcPzGf +hzshzfshVhthgMmRsFRvFqmm +PDDcZWlWBbplvmRRGtlvqQ +ncjnDjbScnBWZjDVfwjfrrVtwLjzhr +QRWvffVVGfDhNNjzGZLLcGGZ +rgtpSSHpPrHSspvNLFlzTgNLlFglcc +SSpbMHpvmwMQhMBR +dHLtBqPCtPBHNsbRNdNNsZVN +nQwntMwJWhwWjvcjDMlntRsNpgSbNNpglFpVggbSVF +QDhJWwhzJtTqLzCmtT +PSLqTqrCrRvCSJWLdLwdVWdQWL +zNjHQnnHjHznnbDMnMMMdVZcpZZJpZWcdJFZ +BntfgNbzfBtHzgnbbbPPSstlQSSGGrlGsrTT +QpBNsBzztgqVtdmp +jvrhGljRhSTlGGvjwjSwGjRvHVdqLttrMgMbtMMMVmdqqHfV +ChTvTvljmCsQQQnNsQ +CQCNSQHHgCtNHCNHHNDJcBJwLPtJBGhMPPPJwM +zRTqmsdRRzrmdzVRpzPwcjdwwhLjMBMGBBLw +hprmzRmblTzTVTVrlbrmVHNWNnCZFWNNFZlnDFSWgQ +hGGqwwdwMqsRDGRBzlvDzB +LTNTfcCFFFCcNHFFBzRSZRBlzHPSZdvD +nLVTFNfVVLLWnwnwdrdbhnrhrr +hlTpcDTpHmHwDmMbbdMMMGTPdGPR +ZzFqNSQqHvBvzzqjFHtvSGRRMPQsJGJWRGWPMRdRsM +BZjLNqNqzVVHgLVgll +ZHHBzSZPVqghJgSnBhqJRQLRRMvQpwZvfNQRMMMp +ctFCDmdDWmDGNRFMpRlwwQPP +PrsmDmCGjtcmdjGtVqBSjJhnSbHnnghH +QmZHTjmmHRmmdPRvHdVlPdrNNLqWzffbRtqpzfWtWsWNNW +gwMcgnMGFGCjJLqfbtNtzzssCW +DwMFGBwcBFjhBBhcDSJQQVQTPldTvPlVVZQSdQ +NRTGfNffLghStLRR +QlnWsdJWmnbWnVqWbWqHPSpmjgCjtSwhPjgtptLS +JWchnllHqQJzGTZfTcFNDN +VtdtcTVVCRctVdJclCVtpphpPhNGDwNPmThwWmgG +ZjZMFnfBqqMjHZHMzBnzgPGwDmhmhDPfQNGPQGfD +BbgsnFgMgMlVdJtlcVSs +tlBMdBnClhLJnTbgph +PhDDczqDGPqsHGrRGPWHGPzcFJNLTTJZLNbNLfFZgTbffL +sHsmzzrGmPrRDRHqhHwmjBVtllwtdMdBSBtl +QscfZsGsVjVtqGmlzvRMvl +ThJNCHPTDDhHHJTJPHmlSMTtTTlBvlnMSzqn +HhCdrHrCcpmmdVmb +WPPBPvRWzvhWhWzGWtBqBSTLDZhgFSTCDgSgZZDCZs +flbJmMJnjdMqNdfZZrFZZNFZgrrsTZ +nQnqJlJdlQMMbVnVmdMplVnnBwcBPGttzQcvtHcWwWtHRHvB +LLsmpJTWCJmJppCmgHCCLjbFtRFghzjfjcjcZttbRg +SZlMPBdBtQfFSbSF +nPqldlDwlBVnvdLWJVsmVNZCCVmJ +HWvNVtHWJjHJsSgHsHzsDsmf +RwZGPFGMQgzpTGSD +PZMlwwqhFPPZqwFhPwnFbMjWJNNBtWNVJlCJJWJjWWzj +frBSzJDtztfNVGwRzVgGhqsV +MPMmjPWGMMmPCQCcbmRwVhTgVwTTqjvRTLww +cFpcMGFplDHfBHFS +gtjhjLffmgjgmbgVfbNdqFJMJMNbbwrwqq +sWHHPSJsHzTZzTGsCdrqCNNddGdGFGRC +ZpzHHTZWzsSSnBBPsTBnLVcpQfcJcQVQDQfcDfQt +qMPqChqjQPRCMqlBrmGmLbPSsTbSvz +nWNHZFVZZttWpfHsGSbBGTbWBSGmSm +nZfpVfdZdtFHnwVHZtNwZhCJRJhcCdDcQhCqDSSCQc +LlwSlZrftFSMpfLCdltTmmmSDmJqmssDVJBmJB +cRcGGhpvDTmTDgsG +nNPcjpWbNzjRRcWhbzWjvnLMddMLCwtdtMttddtrCdMz +NszSsDCMSDzdZpCMCSMpNszfTvJhlvmlmrTfrhlhHPrmhD +FRWBgRjWwqFWQFBBWjVncjRTvJfvvJvVrHhmVrHhmrdJTh +wnwnqwRGFqdbNNtCGpCp +zgsBvPVVDDrDtDgt +nTHldmJQNTTfflcJNrQlHWpmDDFDFhWpWCLtFbphCm +nTTNMlNfHQZTQPGSzVVZSVPSwr +bPLbtPpwsJhlpnhnnLNNZDWhRNzWQrWWffNr +SczqFdFHSTFjmMSMFVqFGCWWNRrWQQQRZCVWgQQgrZ +dFdzFGHvjmqGMFwwLLsPnvBspnsn +lwJwwmblVdvjbbbJvVnlmjGTTNTLqffpqDJffqGLqDLD +ZtWgPtRMtQRQnTGDQNTTqL +gCztMgWgchHhvwlllbnl +cCwSSCVbqwCCWSbZMmGdtBllWBfdlvdt +jzRsJjhPjnLthJNNpmpvmvvMfGvjQpGv +nPHPFgRHLtCHZrqTcq +dVJwCJGCVrQQGTNtLtGm +hWWgDHBzWWWpZlhWBssLDTDsQTLLtswswL +gPhBHpjwHcljpggwwWqvbFvdCVRqPPnnqVRb +zRRRRNqzpQZNNRRmRcZscQcCDmCTTTDGfTbfGhrTCTrbFF +HMvMtjgtLHVlLVfhCGfrfhJhhrvh +LBgStjnHBjLVgggBgHndnSNNQdNWcQQNGZccwsccdQpw +jLRqmZNGtZtvZvHzPfCvSSzhCP +QbwDVHFrVbDVrDFbzPwSThSfddhWPWzS +rpnFDccHFHtZNmMmRntj +RFVdzzlNtrwSTltb +hHGcqqBcGLQZffHhMwSswSWGrnnbMStC +cgqLBgQgpgbbPbPz +lfcgglhfTvmlBvclbgztnSRtSmttwRJwptWR +FMjDjsdNDjNMQLFFLCMQdtwGGzRwzpGwzdWzzJpGhn +ZQVNsVZMPsVhCQsFCFsHHlqlcBZrHHfBflbHBB +vGGQQdwNCTJfQJHJbM +FFqmzghlzhgqjlFqzZhmhPlRgBDLLRTTcHMbRcJHBLcgRH +qFrPjnhZmqnhZZjhhmpPzZmtvbpwtdvsSCCsGwdNwvwNCp +nrFdSHScdRwvdvRm +NNpPLJJbNbppCvmzbHTbmsTw +fWLHPlPtpMNBgGQgqggQSMGc +BcHtrBcnjflfHslsrnltbTgvMwpWnnWpwwwCwCCRRW +dzGhLSSGDdPNgLLdPWTqWWRMqwRWpvzMMv +VPZZNhhNSSDhLNSLdFZBVgBbjHcgsgfrbBJbfs +VMnWjjWTnNNCzzhblbbjlj +FmHwfFHqpDrJzPQLPLbCDs +GrdFfHqqSmmwHSqHfpdMNTtTtZCMMZtTRggGZR +QRlnlTphqNfqdjZNmd +rDtPmGctFrcgDjJcNjvNJNCcNw +bgGDtgDbBWBSBVlblmVmsRMmLM +CcQTQTrrmfQQhZZBpZpSSZ +JFqSvLlLbWggDvDDFHjsdnshBZpjHBBhBW +FgJqNvLRMlMMDDblrtfrTCStmCVtNttz +MRRbbddqtHbMZbqMHHTFTFgwZglWPfgsZWgW +LCcLjzCNGNcvpvLTFPmzlFsfTgFlgs +NhNGcrCGrsrvcDpvVcSbtHQJQbnQbSdHMtJV +bfMfBFcWFsWZHBWRPQpRqdwmMpmddm +rSShvvVTNVhvVCCvThDlSvCwpGCmRmGQmPwmpLRLRdpq +DhRzzVNVVgSzTFcgtnbHnHbfBB +HsTGHHvlvvGTGlHBvlbZstrVrwNjrjVStwVVZR +PPmgcFJPFcFWmWMgdNtVtQZtDVDVdZZjjR +LLqWnMnmNvlBLCTzCT +qTttLqLvGCQqCDlhml +FJjzrRBrpjRWrCwrBrrwpRbbDzgghSmmNhPQhgNshmDSzSNm +bJBrbFRjBVnWBrRBnHLfHGfdVtvHttcCdT +mTzjGPmPPmPNjNBTvlJRlNJzZqrzrSZZSpcZqpgcgcggFr +QWCwwMwWWhVZFbpQDSpSJS +stMMsWwMwVWtwJTNNPvvRmTsNPsl +gGFFNWMMNFTBlLpGpSll +qvccssdDwDbhMhzwHLppTSHLrdBpBVLV +PhJhzhMJzwDJwhZZtZQJCjgWtFjZ +pGqWfqqGcspGqWqppHprpTrzhCzttMBCtbtJmtJbSBvWBt +QDnVPgVPgDCJBMhmBJgv +NlZwFlnnPLLlFwDlDlnPPFFHTMTdMZjTTcjsqqcsdfGdcp +HLzZfHWWQwpgVHjVHr +JlMlMGGDMtJGdtJhqtlccDgVCSTFFSCSDTggpvFTjSgS +JcGRMlthtlVNMJRfzWsPnQsnnZNZns +zVfvMpsbtQmtBlFWBZ +lLSrlNTNRSFRFhhHRmPR +dnSJjjwJJGwwnzVlvpszvccM +SmlcCrpnrnznGzSBBSfzNbtsQsWZQcFbWctcbbZb +JHgwJPjvdghbbWdDZGNLZb +JjghvvhRwhwJVhHTzmfRfzGSMrzBfnGC +JbCmrbnzmntnVJjbCHJJFQFvqgJgQgqLDQ +NGhhhhPMGhWsSSchWlNsCLBBlLFQCgqvgCFFgQBg +PdcNWWcdGdPssPPNTSNNtzbTwjntzbbVwtZpCVnb +tGNgtsNQHsJmwwzddmQw +hMhhDBwMhDDfCRRBjFDDTTWjdWmrmdWqjlmmmjJz +RSpSSBhppDhRncRLswZLGvtGvNcNtL