Solve 2022 day 3 part 1

2022/03/a.py

@@ -0,0 +1,44 @@
+import os, argparse
+
+def solve_task(lines):
+    duplicate_objects = []
+    priority_sum = 0
+    for line in lines:
+        half_index = len(line)//2
+        dupes_in_this_pack = {}
+        for i in line[:half_index]:
+            if i in line[half_index:] and i not in dupes_in_this_pack:
+                print(f"{i} is in {line[half_index:]}, first half {line[:half_index]}")
+                priority_sum += get_priority(i)
+                dupes_in_this_pack[i] = True
+    print(duplicate_objects)
+    print(priority_sum)
+
+def get_priority(item):
+    item_code = ord(item)
+    if item >= 'a' and item <= 'z':
+        return item_code - ord('a') + 1
+    else:
+        return item_code - ord('A') + 27
+
+def read_lines(filename):
+    lines = []
+    with open(filename) as infile:
+        for raw_line in infile:
+            line = raw_line.rstrip()
+            lines.append(line)
+    return lines
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Script that solves the case",epilog="Have a nice day!")
+    parser.add_argument('filename', nargs='?', default="example.txt", help='Input file')
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_arguments()
+    lines = read_lines(args.filename)
+    solve_task(lines)
+
+if __name__ == "__main__":
+    main()

2022/03/b.py

@@ -0,0 +1,46 @@
+import os, argparse
+
+def solve_task(lines):
+    duplicate_objects = []
+    priority_sum = 0
+    possible_group_items = {}
+    member_counter = 0
+    for line in lines:
+        half_index = len(line)//2
+        dupes_in_this_pack = {}
+        for i in line[:half_index]:
+            if i in line[half_index:] and i not in dupes_in_this_pack:
+                print(f"{i} is in {line[half_index:]}, first half {line[:half_index]}")
+                priority_sum += get_priority(i)
+                dupes_in_this_pack[i] = True
+    print(duplicate_objects)
+    print(priority_sum)
+
+def get_priority(item):
+    item_code = ord(item)
+    if item >= 'a' and item <= 'z':
+        return item_code - ord('a') + 1
+    else:
+        return item_code - ord('A') + 27
+
+def read_lines(filename):
+    lines = []
+    with open(filename) as infile:
+        for raw_line in infile:
+            line = raw_line.rstrip()
+            lines.append(line)
+    return lines
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Script that solves the case",epilog="Have a nice day!")
+    parser.add_argument('filename', nargs='?', default="example.txt", help='Input file')
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_arguments()
+    lines = read_lines(args.filename)
+    solve_task(lines)
+
+if __name__ == "__main__":
+    main()

2022/03/example.txt

@@ -0,0 +1,6 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw

2022/03/infile.txt

@@ -0,0 +1,300 @@
+jNNBMTNzvTqhQLhQLMQL
+VCwnVRCGHHJTdsLtrdhrGdsq
+wFJZTbRcnJCbpwpFccZCBfBvPzfpgfgzzWvjSzNP
+wDWgDfWNTvwvgFfWfddGldJVprrrVdNlrN
+nLnmLSnmMVJvSrHqdV
+MsmsbLvtzMjFsCPDsfBwwT
+WTqSCqWSWqSgVZqJHpHmHrhMMVrRhBnn
+PtLGLGddGGMCpprM
+jFvLPPlLjvfjjffsclvPqzzJWTbqNSWZsbSTDzCW
+lLSSrfmddlNpnmLdfSPddDdbZQTZgZjbZgjcQZHQPjQgZP
+MJMnhzBJVJwvGsMRhRhTsHTjZjHFctbtHZcgZj
+vzvBWGJMVGwWGGhGqVBnGzVGDfCDmrqNfrrLSdpSfLSpNmNC
+qGWLgfbWhqpLgZbJvTRWJTvMWRslMv
+FQwPwNPCVFQQdNcFHNcwwsvslRDRTMDMsVTGJGtRTs
+wQHnwnQFPNPdjnnPjhphGqBrfpBBBfZf
+mpVpmtPhVtPBLLbQTJpBLZ
+vzFMlMzvvRZMTbJQJQbf
+srqzvRRqdvzFFrDnvqldFVtwCVCHWNqJHNNcHchCPt
+CQJJLZCJLqNMMDDgGLVV
+RfRFFszTtzbWTFnRtFrRrWvNHghvBVGgMffvmBVDNgGV
+znsjWzstnWjbDnDbTZCpwZcjpjZqQCwSPp
+jRrzzrPjLnnpQQDsjj
+CTVnTlZWHTcqZBcTTTHqWscQsQDQQDsmmQfvfhwDmv
+qlWFWWHTZTlqTFWZHtBVFdlTGdNzRnNngbbSrrSNNzPgPGSz
+cWjbcjnssMmRPWbGsWcMbfLBFrZBBLLgZwBrlfLQZtCw
+vqpvFHNvhvJzdZQZtlgNNwlrrw
+JzqVVVVpzhVJqzhSzJhhDVnFjRRMsPnSRcGMRMjWjWmR
+NznNGQgSRQffbbsR
+jjjCLwdvLcrhqdblFJsFSPfbDP
+qrrvwHqjtLmSSggpBtgn
+LGPtFtTfTfTfLrrWTSWGPrrsszbsjZHzgdzSwzbHdsglwl
+NhHpVpqNNqbdszRRRb
+ccBMJVDNCvvhDNpvNDpnNCVCHFPTmfLTGPMQrfLGmMLWWQQL
+dRgRhVLRlncZSSrtLp
+WJmwvvvjQvWwFBBvFJPHpwvGWTScGsrZtttGTSsrzTsSZt
+FFHJjmjjjPMvfHfwpdRqMppghdRCddDg
+NDTRFSnNsVVBDVlM
+JjLZWqwjHvfrvmHHvjLWWLlhPlnPlChlQhJQnnzPPBCV
+mwHvHmpvwpLmjnvpvLvvNGcTTggRbdTGcbNbTTpS
+GGhZQMsmGRfMwfpclgdBlbblBBZgJc
+tFvFSTSDnDTTLtcFMbWcBgclJrgd
+vzDtzMVtnLTTMTSjSDHtppqhsqqfGjmpPhmsRGPG
+MfJtWTTMJfzBbVWPZWQbNnDV
+FvlgSHSLvmCvZjgcCQQsPQQsjnbVDNVsdn
+HLhclRlHRmHvmLmclLZFSFwRRRpJMtwJwfGGrrtrwfpf
+scsswLQcGmQmNHCqvrsHqfff
+bdnPSMMMClbBBPCdDDnDVMDWWWvfvWFfFJfNqqNVFqFNfr
+bDPTlSTPPbSPjnPSbGmQLCcjLjwzRLcmCG
+tFFJjMnFhdcMMJlWtdnlFczBSZGNSjGGbBGZLbZZbLGB
+QRgqwwvsLssZnGCz
+gqfvvnpfHwRmHTFdFcPdJJmJJc
+fccTzVVcfSmdThTTFJPFgg
+wLsWfppsjBrnnwjCBZnZqJJQGhBdFJddQhFqdQBG
+pZrNCWLwLZLjwwWMftmNzttDcVzVvt
+rZnVVjVSMcrwsNbc
+dLvQLBLFddvBLzpGmddQCqNswzsMjbhgbblbcwshlb
+LLCCWjGBFPmCWdmmPWLdWBpLRZDSPRnHSStRfnZnZTnSSTfJ
+ddfnQRbpldRlRLgFglqGCLqsGq
+BWBVDZWTBTDPvVTZVDBDNMbhcLLHsFqgvHJsLCJCGcHGsJLH
+NPZPDMWZMbZrBVMDDWNmBhMVpSSRpzjjfjpwRnSpwzRzdzjr
+bvPSBttgGmZwScwShS
+NJspjJLdprzHgjrLzLNrnHQCmmcZQWlcQcNQwlwcQCZC
+HdRJsJrdHTbqGMDtgDqT
+sNVvSdTstDCtdzdzSCwTzCRhRQjfclMflppjGhffjZcN
+rgWlrnLLbqbQMfMphpWjjf
+BmrnrFPnnBLlqVwDCtCtVPDTzT
+mJMqlVlttQlFVmzFQMQMbQMSSDNwwdSddNddwdDswRDVdR
+GGZgcfjrvCCZvgCZqvPHSwRBBsBwswcwBNTDTcSR
+GZppfGHGrgGprZhLthFJhFqLWWFhtq
+WDHHLtRBHgDnVrWFVFBTdzzZLLjZzjjvddLsvv
+JlqmMpCMCGMwbwZddTtCtv
+cJJqSplpfSGccJGthFVcVHgFBWBgHgDB
+tlFwbWtQFLJhlBFlWPbwmsQndTrrqdnggjqdgnTgTT
+GCMBDDCvRpDVpRpHrsgdqTjqgdHcsjHd
+MDDvCVGzBGfpzBSNMSRRmwbLWlPmzbPmlJlWbFbJ
+fzFzFHBfnvpHFbnzbHfBHZggCGgtZCltDGggdCCVtZVD
+sLMNSccQLMSrmLcshLvtCGllPtDdGgtJgmlV
+cwLMwwNhQhsWSjqTqHnHbjWTvH
+NWlqqhNNnGtNvvWQdrVGBBQdVrwRQr
+mppCjppMrDTSgDppCDTMQVRwdBbBQVVbQdQsVB
+pgzzTFFFrjHqHnqJFWnh
+ncQrhQjqjVQhGsGBbhtsstTp
+RllWFLRfZrGlBTbg
+vFLLmfNRFSNDfSNjcwqJVrVVzQjc
+mmGrgwmGDGcVWVjNNW
+nDsqfPCHnpntDssfJPDPjWWhjNTTcjjhTTNcqWcc
+DfPCJLpbldRrlrdwmw
+dJDNbRhNbJdhqCnrWjhsTWvplg
+LMHrttLFcMmcMFLmtGplCggpjjnvTpgnTTFT
+czZMzrzVZzHZdNdbDDqDVQNR
+sbsJgbsmzdgRgWdg
+LLLFBzGMLjzzFtVFwwwCPPRCCqQQTnnCMMCMCC
+GllfptwjLjlGFVFjGzpFFNbJDmprrNDsDmDvJhmcvp
+SccPbfbncpcfsjbRjMBCTTFGMTCQtJtzFFFJ
+vvvdgVhlmlwlgZLgmJhWQCWGGbWtWJhzTJ
+NbLNDdbLVmqqmfcsrHcrpPqrcH
+HcgDBJSHTCzjjnMNJjrW
+VppGMwFwllwwbZZrjvnqmzmnzpqjNv
+wZlhtPGPLFVFlGZbVtVTQLLBQRRTSHTSMDCgLs
+HPMMnhBHlMnMBPBHJHPWfdnBmjvLZvjTvZTZDgTgTmQmZhZZ
+SrzrSScrctrwVzCSCmzQjmLTLvGDvTjGbm
+CswstFRNpcwVNRrVVSVwpwpHJnnWWBBHfWHlffWfQMnM
+mlFMtqjvMdqjmMCCJZsRQBnszlZz
+HcNgcPLcHLwtcfZBTsnsHJBJTzCQ
+LGGNhbNtNLDfcgcwfbgthfwFrqqVdFMqMMhMmvShFqmvVv
+NbvbBGNvhNhnhpbgpGfBvNgmRjCdPCPCCRCQmmpRdTmTPR
+qqFSSqWrtSSccjMdQMHFMBjPMj
+SBDSBZZZwGGZNJJg
+qTdHSLSFRZRHHZVgpzhbJszchsnsLg
+tDvflvrGttDCjlQfmCGvtCftczhbzwJczcJgznNmzJNhwgsp
+tQlDCDtrfrtlGrjlQBHFHPVHbBbZqTZdVZBF
+MTwvsQJMvvHwVMMJMQNNJRPWWjCllrlWGFlSFCpjgFVSWr
+zhcmnRZmqmWjCSFrFqCW
+ZbmhZcdZznZfndtwDtMMsRQTTQNRQw
+ZhhVqQTvZvVhSmQZcClRCLPCgTGGLbgl
+dJWHwndMHswswlGbCmclmLHbbP
+dnwwNJnjBjwwdddnjndfWvmvSNZQNrVVmZvZFvvQQv
+trlrlrZzsjRjdFhlpwdpnpdp
+QqLvvLQmLfQTLbLTfHmqHHLqQgFBdCJBBgggCJdhgJwCggBF
+DPDvqLqffqfhSVjVPSPtsj
+gsnVdcBcjMMntGMh
+RQZLRZlZDRJDCzCjblJSDjQZWWTWPCThMTFGNPTNttGwCFMh
+pDlQbSlzpQsjVpjHVfgs
+zgqtCtJltdGttJgVGPPJCtJvQFsFFbTFssNDNDsHLbTQbssP
+rRcwBnnpcmBqpbLHDspTbFsb
+mwRqrqrmWrZnfWmBmnRZlgClgJCJlGJzClGMtG
+jlzHllmPnpHlHZBWZJJDWMBNVH
+bQrhDbcLgsQrtdVCJWfCCBMMVWrJ
+QhGdGcLGwwwtcDzznppPpPwlpnSS
+qbpqvWFHbFHHsWwPqPpsVWZTlDcLDddddDrmrcVZDrmT
+MCgSSJMCztdmcLzlrlDl
+QCRMRSnNtRSqqRjsjLPPvp
+ZnZrTfsWWvhVSRmzqqnn
+pLGBLBgLCpgGpbdLbgMClJTmmhShSRShqSBDQSRRmQVV
+dpJPldgMMbglFdrNWWjHZNccTjZP
+CCZCQzwwdmMGDWMmhCMJgpnrnwsTrFNLgnpNgg
+jfStHtcjqDPbPtvqvgLNpppnHsrsFgnFNp
+fcqqPPPtPSfRVBBRPRPbvQzzhQWGZQVQQZDQMMzGQM
+VVlDNDgppgtNltlrJPbjSzPPzjsMsjBBMWMM
+LmGRmfmwCqQqbsQBMqJj
+cHRcCFfmfmGLJLGFcJLFwfdlhDgptthhHpVrNVdhlvhl
+vSSdnBVpscwZcBZB
+mLHzqtGtNfGHHFNHMhJMthsbcJtctZTw
+GHqHHGzNDNFCfqllCFqVDdPSDQnddvcpPQjdjg
+CMWcwGTrvzDWzrDccDCGzTTTplZgSjggjSpSljSjBpSmgmWB
+nssRttdsnhsdbFhtVFhNpgwNpBBgHHBBBBZSjNSl
+PnVPVPLFtvPvTwwrQq
+tlQlqlJCCJWgFrprPjpGVpQzvp
+SDbwShHbBZZbhcBdDBDSTrsVpPrzzzHVzNllzGlVNv
+BTbbScwRhwZLnLtfJFLFJgWl
+VDfPVHfDVMMfHSPSMTVfqgFthFcFrtcdhrhDQdDmdcdt
+bWGGHCplWnJNpJCCnlnNwdcwQhmmdmtwddBNcc
+HpGCnZGllzlzJWjnCbbnCnRvfvsSTVVSgVLqSsLsLzPPLV
+fQqcfqfSDzDWffDZ
+NcCLCtPCPMtNBwdthpLhPwzsHrszsZssTsWrDrDVTNNH
+twMPBtCpLBCtwMPpJcMBSjjnngqSjQQJbQjjmgmn
+vQwVQQVqcJvVJvCpQBCLpdgSFCdjjWWnMSgnSjgjbj
+hszPRDTVDWWWRnjWWj
+TtDDZsszlPllhPzmPVGssTPpQLcpvpBpZpcfpvrvQvBQLv
+sRmGqqzzzgCtRrttCP
+cffSwNDddTdfGWtgNCrtGMPP
+GGcTwHwHvjqLLjLvlJ
+JSdjLJMBdMSrfwwLpWgzWmvDhggzWvfmgD
+VsRtVllstHHNllsQsHQRzchcnDmvmvnRvvvcnZ
+tGVGCTTTtTFVbsTTNTHsTTqBqBLrBCjqBwqJwqBzLqzw
+MhjTJjlSDrplQvFQ
+RHttqbNGGmbbLmLmdqbgnFQwrZswQrwDpFpppdwfvQ
+gCNmDHHRCLHnWWSCjhWPShPz
+BvzpbBwBmsDrmGVgZFDm
+TnNRdtlRlCdFFGTLffrrGf
+jltNtRCPSlPNtcpwpGzjMBpvbhps
+hflJphNDmmbpfnfplbcvLsHVLsrsZsVvCb
+FgTFWqTBfFPfFqQqTwHsHccVVLQCZZZCVH
+BSSRTGWBgFggBWgBGStTGpzNztmjjzhhzDfNnMjnph
+mDDFjjFmVlTZJttffD
+hhRvNNCvdNMRLzhSzpptwslNTfNQntsJQZZTlN
+WCdMzdMzhMdvRvLhCRLPvjgHmggmbmbblgWcGmcbcG
+cScMdhsDhDDdvGzZptzGcnGtpB
+NPWjJqrjJWwrSFWRJlrlNWJLtZznLBBzZznLqnpqnpnznV
+NWNQwNPjCSQTQhTd
+fVVCVccppZMZMMCBzJTNJHWZTWZzNF
+QrmmPhDqPhsPRhrlbgRDbbPDJNJTnJzmzzfNNTNHNJNWmnvF
+DgbPLbPsQsrbsqLbgllsQQptfwSjwtVLfwdcpCjVwwSp
+ZlsmlrZZJcQmhBhlNrsrJRRbRCRggRbzGCRHgRCDGB
+fMFvdfVTTdjWTTTfvSjVjpjzcCbFHGPHPDbPHRCFGGRHHG
+cdvfSWjfjpdVqSwSvMdLrlrmhqZhhrrLLJQhNr
+sWVVmDJsNWNjcSNJZcNcZWWsHTGHTChhHGtHsFFbbsfHhH
+nqPRwQRgpQRPQQgMQgQLQqBhvTRtfdfvfCbFtTFFFTtvff
+qgrPMLLPpVlbDrVrWD
+VcGjcCHcVHPrGnjQDQgDgQDFtdglRtlQ
+bWWhfzJhvZWJzNpmRTtsDLDgRTsNddFT
+MhJMhJbMmSZbJZwSCtjqcGrrnGjC
+FCvpgDsZNsCbvvvpVwcDrjcrmVMwVwHJ
+fhfWdPhhhhRQQqzdLSRHRHJjBTTmcrTMrMrwmczcwwTz
+qndhdQWndftfhWStfLQQfWgFNsgFpHCtgCNbGZZlZCll
+mqTCNhTNmGTLwLNfLrSrgZHDvfPDPv
+cjsMQppsFnFslnRQQGMDHGZHSgzHPDZDSf
+stWFjcFFsJlQcQtwtbVwCmCthmBTGb
+fmsffcqhmqPsnTCnCcQpzjSSNpBWBTQpVSSD
+vHbgLRvvvzdgjVVjWg
+WltLWvWlqcChrhlf
+CtwjffWrdznRtzCwLsmGLlLMsMmMGb
+cZFFbgPgJZDchMMPVsmlPGmG
+SpNFJBJccNgDcTJJTdbStbnntrCdSrjWnb
+qWzgNFqzqHNTBzFNCZCGPpPlHmdPblls
+rfSJRJnhhnJDjrfvRStCmpdGsdlDpZZZPbPCmW
+cffRvfnnVRjFTWVTLQMFWN
+VcHhVrVCQQWhffzcRZznnZFf
+dDSCGSsSblwDdmLqvnFZzNZplfpfRZfBnl
+tCCwGmSqbqtwsVPjVJWtJHHhQV
+fvvTcWzGcCJrJGJvvHMbZTmRQTbpMdQQsR
+SgFhVgllLgjLgwlwljFqVFSFdjmBHmZdRMdZpbjpmpjBsHdM
+LNqFnlDgVqllwLFLnVSgLFZtCzzzzvCGGccCCDCfvJrv
+FczpzmSjVVpSQrzzcRpRcrwqMtJqwtvtLHvQwtLtnJMw
+TvbGGbNfGCBBLHtJBHDZDMqD
+shgdNTGgvNsflspcPjzVdmppczrV
+JHLPLTsSllgSSPPSPLTRTdjCZGZDGGgCdqZtZCZdZt
+mhFpnpFwqdGbdFDt
+prpWcvnmhmpccBBJMJJlPWLHMDSDWW
+GcMcjDbDMMjqHBHVlHvv
+rLCrwNJCnwrZNLWQQwzQpRqQPlBRVVBRvvtHqf
+zhnrnzdrCwLJCwzwCMGcbdFTscTmgcFlgc
+cnwlFrdMsggblgsrMbncwrsWzjGBTjznBzWNzPzTzfjTzf
+vvVVHSpQvvRQDJGGLWGfTLTBLQMN
+hCmJqVvMSpqqChCJHDZrFsdhrtgFhttZZhts
+sfDNqLNpqpzCzLsDqzbCVWRhjTNhShTjHmmjjhStBmvT
+wZrlwJwFJGlFMTjhBBZTSTRSbv
+wrQrgnPwMsnLbfffVc
+hDcwwGWhMMssTcdM
+NQmLbNSZHQSHSNpbvfdqfRsZMqssjqdd
+LNVtLSSHLSgLNrgwJgJGnBwFMBzD
+CRDfCbfjcnRCBVfjVMfMjZpPptplPWtppStpSlBqlq
+HdTFLGsdLrzNWtvqPTcpgPZl
+JLGmmHrwJGwhjmfMcbDjQC
+VShGpPbWjcPCcTLcPN
+HqfqDfDFFJDvZRJvqZRRqHZdNcwjllwvQQLQlllccwclCMCT
+FddsFmJjjrgGmbSSpS
+NRFFLtFtqFLGsdnGbQSs
+ljMfMBDlJHgBVHgVflfnwdsSQQbddsSsqnqGfs
+PlzDzjljzqRzWzZW
+dtzZZbctPzwdlzRwlcdfRgtQJmFmhPSmmSsQQFhsmqSFvm
+nDjHnNjjjMnfjNTMWhHQWJSqSSQmhqhm
+CDpVCfrjLnnfwtBcpdcbcBZt
+sssZSZtDfHbbdtBTCRBzRDFJCBLp
+jwWgmWlNQNLlcjWhgQlrQQWrCCJJzFCMVMTzpBMMCVCMTwpT
+ggLgrqljLlGvHqttftbP
+cSGBFsFcSRZSQGsgBNgVMwMhDQDVfqPjMhwwVq
+vnCTLlrpPlHzzjbMfqpbww
+rJCnlmClvWvLrTmtTlZcZWSSWPGGdNcFGgcR
+lfDDvZZSvLtDtCQZltCqVBWVBCbHJjRdNqWq
+pGGhhzMRcqMBqMdVBN
+mzgwGrrwhThFGPmGPcFGpwStTfltfDftStDsQRsflDQl
+LjnSjLZLBcbBdDqzND
+rrfhfMRmpsghfrhGhgQrcPNtZcqNCqdCqPzcNZMM
+ZTTgvRpmfffpfgRRhWnVSJJLLWnvJHFlFH
+lstcGcttdczzsWVCvQVLCHHnQHWL
+rjmJrmfmJMqvQTLvqfGG
+JbNrjGjGrMDRJghZggcchhDhzc
+tftJQwCgSjpdWHjbRJ
+DcwvlZBmGvHjdbczcRpb
+sqwDlsBvGNSMQTCNfCTC
+DwDrtvMHtBCvcpDcjCMFtBCblJfJGJbZlfzrRlJdbRdZld
+sPLPmqhSnLQQSWqlbzRRhfJCJfNJhZ
+mVCnWCsQqqLTPWmnDVMFVtHFtMBFpjwM
+scChGddJztdNswNsdDsthvmpVmRVcZjmvVvRSMZVSZ
+lQLCWgWHCWbFPbbbHqLnLPHHVMpVRgSMmZVSBZBjZVSjRBZp
+QrTlTHbPnTsJGtsDdGCr
+fMjgFqtFWMhtjcNQSDMmNlCCDMQN
+sVHdHdJHwPGPGwwbpJGTbGTvClldmvRSnvlDlLLSlvRnQl
+pJbHPHJGVbBswpTcfrBtrhmtrFczzq
+SDGSDGVPqqqQPGrTQVTQDrSrJfHJgqhgJqzhJJmWfHpWpzmg
+twCdCWMLwbtLLjBddgfcJgRHfRRpfcpRHM
+FZdbvFFbVvsWsQsW
+rzrRgqGrwgjRVqJCHLzCCWhtDbCC
+dTZnNpvBvnJdBpBnsJPvsSCbthLtLbbQShQQLHtSST
+BlplPmdlFsslfJmmRfwfwMjw
+PPHSrmfHTnmHnHBzRhbFgfbFwzQg
+LcsVsGtVLtLqpzwBvgzQRgTTTp
+TjLJGTTJWJZZWWZS
+tHcshJcJRhLsQscVtccJLRHfvlPjZFSvmvSbvfLFfFFbGZ
+drwdTNlwwBTpCdCdwGPrrmjjmjmbSjFPrF
+wglnzCDpJtQcztMR
+bbMjTbBvgjZNSqldTlVt
+wwrcFwsrsnnCQzrCsLnRsQZcNlpJVZHdttZVttSZqJZd
+GwLnrsmFCCzqzhvPbPmWmvvfjj
+dcnwQdcdrJdSwSFBBqfBfwMqfBfzsh
+RgmZpWlCClRlTgBZbhHJJsZjfBHZ
+DlNVWgWpgDCCNRDJFcrtQGrrVnrcFPtc
+sWSHsdSrHWHsbdsddBsbjmfwffmJDJwcfDQgfvwJDj
+ZNGPhRqCCRNGNwSDvmmwwgDhgf
+lGlTLTGTSVVFqVTqsFHWntbWBsBsnBHb
+QRRgRvDwWDVjmSbDnbTDlDnbqS
+rHCPPHrcLFJcllqbTlpq
+CldFrNFsgVhhhWgN
+qSfMgNqfpmSmlQrRFG
+cbBczbtbZTcPWzcrTrmRrLGFTQQFmJ
+PBZChtzzcWPcZtBvPjtzBBCfHMMNdDgDpMfVfVpHMqNR
+LJPPCHtgtLDfFfvTLwfv
+pVGWGGjjjplhpGGVjWnldsvrrMFvfDMTWBdFrfFF
+cjlhShjchhjGGmNVjplcQgmTPtHPPJmQgQHgtqgZ