diff --git a/Week_01/README.md b/Week_01/README.md
index 50de3041..3766c31b 100644
--- a/Week_01/README.md
+++ b/Week_01/README.md
@@ -1 +1,23 @@
-学习笔记
\ No newline at end of file
+# 学习笔记:
+    
+##### 做题感悟：
+    做的题目最深刻的是接雨水这个案例，按照自己想法第一时间只是想到数学方法的夹边取低洼，很明显一试发现答案不对，看到官网的接近二十分钟方案，
+    第一遍就能理解的是左右扫描和双指针法（得出结论：自己对栈这类数据结构使用频率低，理解应用不透彻），然后自己按照理解写出代码，
+    其次才会去花费更多时间理解其他方法，其实一开始预计的一小时远远不够，因为需要来回看题解直至看懂，反复调试代码直至不报错、不超时成功。
+    其实这种反复的操作确实比以前自己考虑一个问题无果再百度一下得出深刻的多，因为百度解决完当前问题回头就抛之脑后忘记了，下次遇到类似
+    还是不会甚至想不出解决方案。
+
+##### 课程体验感：
+    第一周的课程看完感觉和体验课程的重合比较多，而且课程间也较多重复，一些算法技巧或者内容还是需要自己课后去查找、阅读、理解消化，还是
+    自己更多的时间自学，不过课程好处是有时间限制对自己有一个很好的督促，不好的是自己的一天时间没有办法全部投入学习，上完课课外自己的时间
+    还是很少了，学下来感觉自己还是有点混沌，还是自己时间花少了，总体来说课程质量没话说，老师讲的还是很详细的，毕竟开始学习，课程结构脑子里
+    还是没有全面形成。
+        
+##### 自我反思：
+    第一周的课程自认为并没有达到自己的效果。首先课程很早安排下来自己没有去主动预习，一直等新电脑到来才开始学习，这时候别人应该都快上完
+    第一周的课程了，导致后面每天都在恶补之前的预习课程；其次自己在工作几乎天天加班，回来看题也只够完成当天的作业，让课程一直延误，挺懊恼自己的；
+    再一个可能是算法第一周，感觉自己遇到啥题都下不了手，下的手的都被称为暴力解法，有时候都在疑惑自己之前开发项目写出来的代码是不是很烂，
+    但是看到很多因为特定题目写出的特定算法代码技巧我又在怀疑算法有点理想化？这些能不能适应工程应用？毕竟平时开发项目代码都会给后续变动留足空间，
+    所以挺疑惑的，特别是看到群里的同学写出的暂时解决当前题目的代码。最后还是希望自己第二周不会重蹈覆辙，能够提前加快进度学习，让自己克服加班与
+    学习的时间冲突问题，学到更多的内容，刷更多的题，形成更完整的知识体系，获取属于自己的算法思想。也期待自己能够有时间按照流程完成以下： 
+        思考多种方式->写出每个算法思想->分别完成代码->分析复杂度并进行比较，如果可能以此拓展。当然这是很理想化的想法了。
\ No newline at end of file
diff --git a/Week_01/RainWater.java b/Week_01/RainWater.java
new file mode 100644
index 00000000..df2e3aa6
--- /dev/null
+++ b/Week_01/RainWater.java
@@ -0,0 +1,70 @@
+package Week_01;
+
+
+class RainWater {
+
+    // 双指针法
+    public int trapForDoublePointer(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+
+        int left_max = 0;
+        int right_max = 0;
+
+        int res = 0;
+
+        while (left < right) {
+            // 左指针矮与右指针
+            if (height[left] < height[right]) {
+                if (height[left] < left_max) {// 当前矮形成水滴存储区
+                    res += left_max - height[left];
+                } else {
+                    left_max = height[left];
+                }
+
+                left++;
+
+            } else {
+                if (height[right] < right_max) {// 当前矮形成水滴存储区
+                    res += right_max - height[right];
+                } else {
+                    right_max = height[right];
+                }
+
+                right--;
+
+            }
+
+        }
+
+        return res;
+
+    }
+
+    // 左右扫描
+    public int trapForLeftRightScan(int[] height) {
+        int res=0;
+
+        int length = height.length;
+        for (int i = 1; i < length - 1; i++) {
+            int max_left = 0, max_right = 0;
+
+            // 扫描左边
+            for (int j = i; j >= 0; j--) {
+                max_left = Math.max(max_left, height[j]);
+            }
+
+            // 扫描右边
+            for (int j = i; j <length;j++) {
+                max_right = Math.max(max_right, height[j]);
+            }
+
+            res+=Math.min(max_left,max_right)-height[i];
+
+        }
+
+        return res;
+
+    }
+}
+
diff --git a/Week_01/RemoveDuplicates.java b/Week_01/RemoveDuplicates.java
new file mode 100644
index 00000000..3d16be10
--- /dev/null
+++ b/Week_01/RemoveDuplicates.java
@@ -0,0 +1,27 @@
+package Week_01;
+
+public class RemoveDuplicates {
+
+    // 有序数组,双指针可解
+    public int removeDuplicatesForDoublePointer(int[] nums) {
+        int pre = 0, append = 1;
+        int length = nums.length;
+
+        if (nums.length == 1) {
+            return length;
+
+        }
+
+        while (append < length) {
+            if (nums[pre] != nums[append]) {
+                pre++;
+                nums[pre] = nums[append];
+            }
+            append++;
+
+        }
+
+        return pre + 1;
+
+    }
+}
diff --git a/Week_01/TwoSum.java b/Week_01/TwoSum.java
new file mode 100644
index 00000000..27c896aa
--- /dev/null
+++ b/Week_01/TwoSum.java
@@ -0,0 +1,28 @@
+package Week_01;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class TwoSum {
+
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> tempMap = new HashMap<>();
+        int length = nums.length;
+
+        tempMap.put(nums[0], 0);
+
+        for (int i = 1; i < length; i++) {
+            int temp = target - nums[i];
+
+            if (tempMap.containsKey(temp)) {
+                return new int[]{tempMap.get(temp), i};
+            }
+
+            tempMap.put(nums[i], i);
+
+        }
+        return null;
+
+    }
+
+}
diff --git a/Week_02/IsAnagram.java b/Week_02/IsAnagram.java
new file mode 100644
index 00000000..6a81dd31
--- /dev/null
+++ b/Week_02/IsAnagram.java
@@ -0,0 +1,48 @@
+package Week_02;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// 有效的字母异位词
+public class IsAnagram {
+    public static boolean isAnagram(String s, String t) {
+        // 适应如果输入字符串包含 unicode 字符
+        Map<Character, Integer> str1 = new HashMap();
+        Map<Character, Integer> str2 = new HashMap();
+        if (s.length() != t.length()) {
+            return false;
+        }
+        for (int i = 0; i < s.length(); i++) {
+            if (str1.get(s.charAt(i)) == null) {
+                str1.put(s.charAt(i), 1);
+            } else {
+                str1.put(s.charAt(i), str1.get(s.charAt(i)) + 1);
+            }
+        }
+
+        for (int j = 0; j < t.length(); j++) {
+            if (str2.get(t.charAt(j)) == null) {
+                str2.put(t.charAt(j), 1);
+            } else {
+                str2.put(t.charAt(j), str2.get(t.charAt(j)) + 1);
+            }
+        }
+
+        boolean res = true;
+        for (int k = 0; k < s.length(); k++) {
+            if (!(str1.get(s.charAt(k)) != null && str2.get(s.charAt(k)) != null && str1.get(s.charAt(k)).equals(str2.get(s.charAt(k))))) {
+                res = false;
+            }
+        }
+        return res;
+
+    }
+
+
+    public static void main(String[] args) {
+        String s = "hhbywxfzydbppjxnbhezsxepfexkzofxyqdvcgdvgnjbvihgufvgtuxtpioxgjuwawkbaerbsirrktcjcesepcocaglbassivfbjhikynfsvlbtkawstrclbkpuldshfgfvwjawownulsggsxhhqglbhjlgltfrqyjntgldlgorgatnjrsywlyngxrcwfojkmydmjbzuquqnzbpwlcbdzgdicctpkgtbdjgywkyrkityvohjbuvmzdfyicyplmrpygdhaeqbuxnehfybsysnnmzbhprsyjmtpcrzeqqbirofzjtlsyofdyeffkvpuhzaflwjfhnsuyryetjuajjnjwvlvrhvpenaarnzoafztixjrisfzdlepcwhxudjpsiirtofymnovacjmpdjtethjqfwduekczlqhsfjgqesyoxcfooagrdhyvsmssbhsclnlblhobvhwtpyftolneozlhbtjagpgqnnapktyevdvjfwdnbwsbelweoflhyhifprieuvfcdkavqxkygjlaegqfmzndgxbsccjgpclxmlpstrqjtqyvlqcopnahqvnpvkjimfdlosvletmamqjvotqwhadutmfvlgldniixvdkmymfadckuaglgbuttymoqmzkaeqxugsrnfyxzcamwxujgzupefretsvbdweuwwcizjvhcowtmwgkdafcpzctpsjwdocgofivyshwdinbdhbxdfhjsrrsfchxkeqndgzauyprwfnrbmunanqnhmjhrufoinakwaciaoerioqffmipfqujfxwofqdyjbhagkyvmnxcwomgnmwlaodxgkgthnuctoozxrebjiynjwohtgukyneyofabpfdrxklopmxxiwjuxqpaazknscagfiaetmmwnwpzceglupqvlctywtpluoqbzdultcsudubqclbwlxyfboimfwriugfulbntvdwnxgiycxvennakpodorvpiknkridcumsovvfzikiydqewgjhacrkxddqpncirzlsynbjwutomcwphgggcsnfqxwxguokjvihoewffngivnkapaqjrsshqfbpfqhzihzndzeyznzyndmhfmypgwsqyernninzijwrirmbebsupvukfjddsjbebfedtdcufnubxqocqeqaincaadorteimkecpkdrjpprqtrllypfiktvcfadfotgjghhtkctgidwreyjulbtmtpwicbqalejtxsgjqepzeduvwvjbbxaapwvmjuweurhdbacxaygzdyitwcwlguknhqxdrfpfhstgnwmwagcblxkqjjwxfhmpunstfhkiffqchcohgcuktfplffqtwlwcsddkaeijajkdpmexteafezquyfonocuwuxrvigpcqbzmxtrvctovnvrobyjmjnqdhxqjxtltichttiuemvxixfeyqzuzxkwmyclbwutbvrgtefcdizjnkmlsvrujtiqhrwpnzkdtkwogypvpittpfhjtlrjtilubngkkjochucmdudfcpudjhiwaflmdfgsjqlwqxlgmdwouofjnytwxumjaailltmzrrfvqcawkzytomjaaafknfnaaylmqkvyeljnznomervgdhnqfhtpalziumhilupdsjpvzwjsgqtnovjneotcsfdtqqtfwjlhsbhumoyjnpuniqeszknvzitifqmiezbzvtzoswezulpfylopuecqcefueesjfhvyddsvozowqtyphlnuridygcmjhjtfoenwbgtramegbnabtooohogyoqfmskrpayzbrsidfbqextanotbkzopgdidswzxveqtojspsbwdqsrrspsyddgwntndfqfqeuvmrnyjvdrpszghetjnbpitorzonhihbzncpwvnwndriupumwihnpxskwsvjqzuetprscqnihpfebqobdezwohlubpyoulnkoicmtjyfsmvjltsxtvydxkajhvkcmhrkeuudrgxjezoeessffmheelwvotkjecsnwybtqutmkubtzbwshbacffkodyhgvdrqxwvtfwzsytriajkjjxcrvypyvmevvqpdknftdieqhsvgedaqlstybriqbeiczokoavsgizdjslkjzfqrtbxwydojvutxensaxrtapxatjrgdvecxocrisfznweidfvxddbmsmcmaostsrlvwvxokcecazxemwqksjnqhkegwcgqltrczpzyjopqmccgjpnfcxatmrsxvozdtcttlxptjhcwmjgcyltnrpicgblfjkljdjqvioxaliduasggcxviifzycctasdhfyetjljfgwjhjssryjaetfbrimuudxwivzpmpbylkikvgebelhouaconsqiyrjqtepusujnlpkkztlbrnnmllrebjamtsszsjyaljvqwklglhpoimqrspabinkpwopignvejbulvugpydnljwccorrvcbncioxtmvjrmvujzrqhfaphfhckmrapmopqaktegfmdnfrvmqzhngbwsijdocmhrgaxspclqxzptviiyhtrniflftpkalplcfoixqcckmvzeqozvbyobxgxehhrvezlkxdvloeqpmgjyqnoroztieaspauxwprtbmlawbxndadnqmknwbmnebiqkpjepdjudweevxtgclllpofytkpvvmlpllxbvkhcftqpzhrlaujzzforiafedqfrsxinxfnbkxjdntfpwquvluuxkukdovviqbtbiunyybkblbifsarcbojrjuityotqpwwoclttqcumithvhgajhlhmcoerwrmyjuunnbvqrghwniqatjnqrjgsnmdlcrwbnfrctsvuambecjkzzkuchvsuwusijrtctrcebafwlkpcoossaagiweaxauwyxhgchfdeqrzbnldmrzwbatqxelzoueeulmgfdxeqxqiaiwajqyihkvivbzhkjfhgutzvxrgmrqsxlctmrvnvybmlbufbmujpezuwjwfpwagltzicimdxyjscoglhbazkcamnchdhuwrqzbfnceikmolfjagmzhlbzyvdffmkeyfcjfovhogdkdszhomhqepyeadooiayofdtnlxwtkprlyozuimeinyiezyirpjfmhubdhmaoraogqytiihxgidzkfxdwqyadvrayajqilwddlyxmhgkwvcwsbqvxbluheovlmugyweciydchhoxlhvodmuvnaodxkelyuprppqvfupddzingyrxtpisrsuuyegruplcogidrrqghimxendmveudzemtwnmdrfxjiqiakglodvzxcdxzbtbobnvvoxufqnmdflgwghbclalddgmevnwzhohbhfhocuabtgvixvfbivligtiyznqmhsdvbfxmylyunerawhdhjlrbgvzljjgwbjhpjhgbmnvwnvjwtdtdrftstvrjjtnorryghqgsfybhncacxoqqhupvtjdnbdranemfywjhtgoxjnoqwsttvsoxymelwnomlmphmrxtnnbsbyelescyspuijmcxsevgorelseeyddymdpjbpehjdwsqrtihzhgwcgstlkallcdssiyzpvephkhsaamntlajcklwtekeupmwlsiojaplbrsnsvzqfuujkllzsiljzqmlvgibxssjjqiocgmvslmqgrsxtazfnbzwdkzninyuvmilmjoexygejggpkbrjeyfnfuctourngguxexoebgdrpbvjuxaqmibmoifsnbnhzlyssonuoqnhhxbkziiudkgtgucbvybmuflvdbdcfrggotqyfishaaqtgwfbdcntpxbtsmokrxnvrzaxfejuwqpgqfirokngeeyejngavztbdkdvtprmywohleaqqfqjnyyycppelbvwlkozdtwuubrjwkkmpavgemwmocvchoquogsjkebulbrgexqjnaiddbdvjlgvfntnkdgkmceomdkvpxtztfbwqqlwutlmvjjzkbulvqjxubuzegteusicmxqpzxlebvkndncxakvnnugqcbdukylzurgtjbcpcpsjbazlignnxemzzpkkhmbdiakeikioibotgyxzovgchtftfhcbznknjilmkudtzifiemrcwbyicspvnhxkzcjaxxcmddlesvixymggysbfnkqcgmsavjqynzehkeckesyddjgqexzmxepknwftptjdtauzohogaptcjdayexbsjxnsgacgztulhucmjqvrqnhuxxcyrawtznhuugkwylkrrvzihwuwhinuffmyyerikwiybcqaeaubmprvzosefwxruzrdqvhkdpifujykelbwumnfpuqksjszmzbuurnswgipwnfzlxplmodczmvxsvzyvdpllrnssiumfbivummsugxvxnfwdvgakstdnkxkjohcinmqbnyqtoahsakqluxrfxlvmhsgdpipgokharbgkrbowropwqaaqkyvhxatqrajmoixrycavnoisarbdqrlggbhliypuiyubulfazulsspfpzzpczxmxtrkjszttlchdpcuoiqnqibnkrereaeexhnqbqwadclbuejxhnmoarhtfrewbwgzzdtwjrkcwpplkezxufpvvdiirpsiulomzsefjnpkodqdyffwlzqvzfabnzwgyjfwyzeknsfyjagyirtlhpplhfcsvttdneoongivvdvxtjedjaakjobmkjnbedinvocafrvkqdrqdoufrcqvjroztpkympqbkuwelwarfjyndkyxkspksyosrqpgafamshptbxzbdfekqhgagkbvkgeinepzkcdnmfxnyqyjhjxntasxgoghmhkkpxvcisjkvgwilgubjxccmffklniynomznltcmfofpehsbfswyginakcvdzhkbrrccnerkzkfxzuvcizvanuxkiotvttqqnngopaewpaqvdhefzrrdymeodzyfufbosecnqkuvhxgprgnfbiyqdkqwwujumesjvxvrfvkknhhfhvegwmwrachpbzwrjsffjbhkkktpnzgtdgzgfbmlmymznnfgnhcftfpdagnbpzftewnzefuqkfyiwlmnyvtahanbigapagjqmrixuyhxhlyrwjoqzdvbhxxfyfbwfsfacwqujjfunypywngdbynsqxplfxtejbzeytcgsabjyhvaxdyxbcyskdfxhjuwmisnldbjliejeonzsurrpqqivhcujjwsfubukdglszfzwkjqxdybsynrkonufpvhlbirqubbgsgbegmpybtmfmjsklfqdzvjbqndqmqwbpczcbksrxyjcrlrlmxkipsffugjmfvmhbhckkmvpzqpgspqkzpnnhcplcmimnmnckuvhuwlkqxhgwqesqjhonuaewywzjgowhuzfujyyflnesowydymqcizllqinuzcxhpycbyskvufloktvnvisxjjimjksxmogvpqdxuzplvjkbplevzcovmlzpltuajpwcdqfwohkhumezhaugjkdhxhwvfwgoxqniwglnwqyhzcjrzholyauavdjqjrwstkwncmmxsngzmykrecmbfabixkwxtqtbjmbnplnalipmefvintguxpsgwvvmvwbpkytxmqejtqmnihfsbqrhzcjshotetczitvdifzlghcxjdswlbcnfdxfxcpmgmmcetagnhrutprhjypoiyolykxgprurkqyplxhgduaffbzhfekawtddjqvuxlalyvvjxzxxgeqrkicyzbdszlbplqujcjvqlbtxlaweqyyidjfytgcgqusgtorexawwebddumpqlhhizrbojmpwaixrsbbocgbjlwjfolifykxnousrhtirctyptvqtlwfuofyezstiwzdaygaucrbbzcluqykwbuduedvvxzgcwehykvggnrasqhlezaihzosgpaygrdecpdqofauicawicbgpjzeqkvytvcbhdyvqmypjkarkcrbciruzifapzkaisuvtlglvfnnwjocduysozqhkuvkppytoedykmbmsxzoqbkqepmivxxadpacmoodqvbmrkicxnllrhrtecsbviqycodvgvkevzudbktybzyffdpqafilhgtccaojtanoknvccpjcgtryxcofprbegxebtlfpgbahpyqbdlkeiqdayxaadxgcicdugnhcbmqebdtyclbmbjalmzbywbtovlclxuwqvrlmyptdtxnkijwxnlnnpsfstdhbqgjjwzrfxykdkunnaqlvyrgbamuvzarrdfdgsrclwwxvuvafnbhwzhlqkykuhhnuetjykmsxzpfnydvtpphalqmaxntnrxvyaswebdimlcckjtnhommgcsocodwaavazrjaiywuqybqwarcatjcypchbnkuwerbobgiirdooqsmqqsergkqmkfxsvufyyhziwmjkamflrsngrrsntfojjjbwyjbpvcrbihdvwhhnccdungtfvnytcnmvasnumxmyrkgyycptvhdwqhtiaehdfeencmxihtbhrzlxstdmwesfcysasacewvvyzkuoxxmyvsyztcvtyqqifdagubpacyiwgkkcinngdibpdywunhvierijzaqyitxsrsadoendrmykzzztfpxgzkcrdqvvskjsqywmumztmibazouprbubsdprsyalrmyizluuxnolvdstornbtvpsgvidptlscjrzylxjjiyefxcdzrmnrsoplqdyfedtvahndirebpqkwqnvzurxmzlfwuzxcdausblgucdxsxljsjwgnrdrbxnmltitjsabfqdbhayodbukydqmrgocprociejzvohnfrzzpjijappmsqoctbfjeiladtutyjxgzukqexeuwgbiqywebezrbzobfdasiwtfkmrqnlkgntrbaeidznyoyiztivqcufqpqfxqfhuikukmsmynglclshyyaloiswxqoyyqinlmkpgutivzhwenuvcepbwkvorqseykydpzrwgvaxhcazghvvsswurwnqmhbzkpumcihnguffddbgvgfeenukhsciynysyaejnvfytxavjozmtmpdgexhylacpgfqdnmmtqwqptjrrwreexcmgglxvkfzklmrfpvoxvhejjvihraszgdtbqcbabuvsbksxkylbisjrqieicqietplhnomeveqvozpniifutgwxnydxtwnrnnzwtunnywsszqgoyrweqsqjtopotozbdtyglfvjfdbrovfbatajrjgttzqqnjxivvywmjaeqxpmnaxnsfcfnbsmxdytbghnlnjfkcazqadakgazvewpqccdaabhpzhervkxathjizeuuhzivpdwulmmfdwbkkgxorddocvvhqygxjzqvsrkjkrwgyahdngcihvkmwhovauybwvapomiwscvjrnnaxpfyrshuupwrfbmugoxyzedxujteludcshfagnikwbztuzmdohxmmcdaduiesmnjvnztrsnbackpvkdfusmixjbdnuenppdpyottqmsfnxtqllnpxdfxjabntmrpwypcgvjtexxhfmbzfoiizjtdtfsodmqaprfudlemamovfdzqbkyhpeopyxbdjloqxmzvqybtfnffaoxdulyxlpehkyzgdhexgdjzxmbczwqsijkecthakunpogszzcutmcintimzmmfaozgdoyjcnwdcsklpawhggsarraefboxocnwlpxdruoyzdtvlagktupkoyswmnczymwhwinwooznlhoajtjuefvxdxbmzfbikuusqrutcfogvagidvuxxtgyshtovetdhzqijctgzenkshqvlibhkhwwnofbtyshrrhfcmsbwqyzagmlpoxubcfplzxdfheziweoghykcmubwgkcochqlkmidmfmzvbdkxoknjrjsyzfiemgtzplatkmhfuvenevobeyneyobkjuidbuvoyaqzrjacecuadmslooxbmzfmuawexswqupvawrqzvihhkfmsotolkdgmarpkkxnfndfkteqewywjzagukjiqhdjdnjxgfnmtrmshswaxizeuexrebctoehacerwfjjgodvicmgugnlngoofgotbztfjcsrwblvrtejthfmmzjjcrvezmczizazzpbdwytxmftfgzdqnslpezrnodslgplqkitigmhhhonadcxhdnexymvlprrshfrecizjnezdlwkupvkplnpvhvcsdilbscxgyxtuwqglkwwxljntjpzsjkrzxmoyswfahhgelyqjhvpmtgpmosmbmsqsfbkeedtdnakyvcumuxqovcnllusoxjufdfgdsjnwxsagtdkjljnfdchnmnlsnqaugqmnzzpzohlatgwhrxsnvvxxvahxwbadqrhraqmstcewlrsuftmrtcxusjkiyemosbebjfxqmvxnyhfdximdbaogpckgvbctkmcusigwbpulpocohlqxtpuqsemnkwcydjnvlrpwjyyligswnphrkbaytllzlmbnultpfcrtyxrvzlucshoxrlzujuwgqwssbgfgpoauqmzzfeppxxqcffangjjrkylvfirlvlhmdypetylrrxmewbuvcylzloskdrhwqaogfephqdyhymqkllwiakogsjvivcwtxcarfzyeuquvlnjwrkptchqjvlbzrilciwuajpmitxiljqeohbkunqyqksadaqkjikuxqznaaihtqeomxkasspyiquazvdqufjysgbqujoyhpnjcgbekgmkztovlkpmqlcdnpmmxyyxmaysxdlzxnpvwoyxnqtstgajdlizxyoiiildnjyafdavyynlozbapbvizlhlpppmiaygngtsevhivkgvmoekoevuswjiefzuwqnpfwwuwcooxudldfjifavbkkidnuqtidunubbabtfsltdwgqfxgoqqylmfyjxvxedoxqpmknbxaqkakvhmtgygniotdikllibsaixidziltnvuyyftypbhaguvizawxijuwiwukkmsaefthkvsdjvvgrbtpwmhwqdlcifjwmmexnajitvzhbhvnhybbmbgexdfdapldjkuwyigtqsgbylookxtwrqbcyzluydbqltcogsyzflztstcxsjipdxsmhoppoexahpaguwdmdtaogwfgkzvollmucphpzkanxazegyjdfkbxwshttzexvdqrymwzjlqphswivippgoasarylakkixysabrvwtaxswkagrlltqknpbhlglbrtycfgelazcoeaglathkfbshvbcxpephcvzfnhpslqhsuldrpnltqcncxdkiawdikeaoweadywevhzfuzxgpwyeqqyfzdmzpfbdenjtcxhbydpwzntbbvpxelxitqjlnvbevgkhdmrumildyuxwmdpyiwfnocgcwlqtnoogrbwpmycyozmccslikmskxdfolnpjrkvkfgbawawnxhtatwhfbenpxlckcbzjknlsfmgypvbrrpjzbwgrcruakqlgtkjjcrhbkdpcqhmpcjdlyoqigfqeimtlwfdsxojscfbdbqevzegkbymedbkfodgomldmhplzaaphenfpgimfsdkzooqvdptddfrneapnsqychajjnctzqsjwhmwanrboxnizydzklprckkgnrxydmjbzjswlyvvbsyzfsamrhzyfzaafdvmvglfhnhqxjfnomrvhikavprpvjdmsfxzbacydtjqcwfrrwfinucsyvhmwrbabfgqcvlbvixbpgumiukortiklgcysdnspslwicnpkcildcarfbxajpojcdwotuoivfdcebajgtvxqsmvvgxlkojfxkovxllvdcfwsssmgcrwuxopsnvrvfyneamxjtqegddlxdgmgrvhaijmsuqufnpuidlxlqmkajvdbdgamtutvkvjcijpmsvoqkhtxamzkzvfnuyjtzzkcfebpxsxktphsupzlxvrhuldzefpkjjahglzquroaavwwsmyzvocfumnxuemysqtpxxnjqqdarwzupxlldgqxbhrocmaqlfyeghedhrugxewggvpizuiemgnyvnmdymlvgtflbfgcnujpkuejymaheiginsvfxsveqhjhfndxspramoskwschxugkvlvdecunquniiivpqizwnyeipwgfomzctopbcwyhtvwjiretdqvgycxwmvzrftsrbdfbqbyhcqezbqarbwdcijrazroqojwrifpwjrtzyhkuhigouheybmrasdtodhddappfeylgraytlxetjophbqgknbcufttuiramawebesrzsbtfaucyqifacyemkfimdhwpzbwdakwjblsantzlcudyabmrklrrnrahosdxnwgwsygewylfltlxejjgzgeptgaknqxextlfcqvzhpxjvrobzkkqczwitykdmqardgcribfzxpzylfzkitocjhgvtdjxavkwtkuxffslvvfrkyllnnxitnboxkutezrepxkxxamrhjvmvaffctuwvzajhhjegigbbiwsscyqikgkwysnceshzjwpeuyqfrnfvfeetagpebaiybxgutlyrdsccrsguxzqvenakmcdhayzmuulkuiuryppecdxqnisszatfowerauhxcldoszqtduzkpwpbwmaxfbqppdiqtoslkouwvxvbaixhxjpttxwxzkqkjzqhcnvnbdhkcxlxnvjqaxlclurimmnolvixxodfjzbtyeapqqfypqbcbrvwdquttbancdgmuhuqbnyxfckgffzmkwuvfmszjnvnfrxogksluaxffcghqorbgxedbjvojvseoxhbugjdybhmrsiwkdgprfgopgccaqdcpfwiftcyjzljocinfjpkqngmugfjqgtcoagawhfkdkyrltbrwdjfazlvvxbecybyeaikfolankjusfjwsziwumrofycukfdmpaocphfuknwsehhxjhmtafugpwckkazjsytjbeihobkxrcqbznsdboiegdkagrcmrfqvyhhizzpnbtyvrzvosnqguhhghbhldtstvzxrbvufwsvijukhyafqfgmfftyjwmrkxeurjujlamcstwlugskqdnppaovkqzginpluhwxybopsrusapwbwhrgygpsfnghdkouwoiafokmjcnfrqaremqcrfsfzqxwalqfmpshmftihexccdovruodydkgmrjltvagsqswkwvorywcgelkvaikkpjbobyxaqyljtybpcdrnswdheyygismrsgjsirpgdczkegnwdlzibocehsbncivftqfxaroxizmzhyijqdvvyyypmoaiztjiwmhleibomoymhxmobyelnkskyabmqsjulekzwydfekqrpayicbbgzczacnpedksthppyetucsmweobsdcjhgdhgrymherrtijjtgqgsqjxidgxdcctgvzsognvzcntochxunfmeiscdstnbiwqlnsmfkosgnjfpxfffnjbmkffkiniisviynbhwenalbilganfnjycegfzzpoywdxmeyujoaedysdabgnhllfojxbwnxvqtlekxisukjwmelujtcznvonmmhcltsgdedgrmewpkxhfpkqnvjhjajagocvfquycohcufzcitivvqlkdjgvvoldpgirsllgowalrwtxqlhjavrpupdjfxztexjmvloojkpoekjunuyjicceixltgwwgqjmntrggfahtudejqpkvbfezycyacuvtrcfahnscilpxcnakdxmuogzxhvdhepkgwcfqnynjnpwwwwpjprcckzbpekxxwberwygobceyvalblpppuydnoqhloeoubptqtyqobwkimjevmmhhdhutwiarzmypuzunoesxxyuedebbaycbawrsoknugmlpwjjnajuoillolebrxsyhvyoqzxcufyikvfgncukmwcetgnkhsotriumgbmgmphcuqeqkfnrjipguhdrbahlyqwhtnuwnqcchtdgsgxeqevdycgwtiqofsnhvuhejkuipfabzvqjhdbbtuwvzbouancgkemccyyvrmtuubouakeuxydehpabvlbnqudwpylubyxrqgynkirvljpnzwgnuiwhevffztewzsysegndtmmssktdgjahcifcruicxqxpymcdwgipjnobhzrsrcqjggcqlkuycxiuopykunrotgmukqkhpvcjggdddrlduosffrizhglncpjjqsfjebbkzwamwoofajpubrgzqouwhdkdtuxqbhqvqnusbyxxeezyuhpatdsreaiinfkukxryycpghwsrkgsvguilifvtvzghzzmhsvyrgfkhxsirhncjxzkuiuyyaimatfenvjjhsrklfcnyorodbojnunndaqbgxofljrlayczzbnxurqiebpdwvevjndqiaphvxbzlnwzsqvrqlekqzxkliikevjcemhcvpwcrjrcxrhpxvfhelcynmuihcjkybzvktcaetsqqsfkxvwjyvetvbnjslfljvqzkagrkighgqrwaxmmsltgjnrfhfjgowkpztqtwjmewfowztsyvwlcyghyhsgvecyjvzwselwbpezhmmzgizbrqqcohyrzxcltabkddkmamwuckiqbicummmmkhwhzzgytotvlnvlryzoojawgxploclzloznnokmfxfjrgvfpkqfafqixdoxflrrmdddmjxgfgoznikzknmrczeqfwavbpytamblsxmbcjbpscsuraqhttmamxhaxgetiylrbhtbymajkgxckluctfwbwsgomhrdjyyzpechijmbwwdzxpuzmyvcpezynjcpjcpliuoaghpfowjvekehpchzkdncqubbvepovfvhlhvqzfbvqymgrhznpncmmynhhlsljjocdxblxbdhmbehfoyuuylurcocnfoqhynvoolcqikrmwbiocbwvpjskohvrolghchvjlydihynakxbndqgqcqsncgknfifwbhisdvrfvidsagrizmsakkdhngsohwtoloknapxzmyjbuojxniiwtkbfytzxootiqrdqnibapahrisjgmhnfnaqbqkoxsinddtsnfqympwjyrmdngimvzxtzsfeezgifacjsuymbrscwezdnnkuyvudcufthkntniodcsbfdmkigtnihqbagwbjlqpbhqhqgtprtwhunoiaekmtnhshvkizsvideqpqonfjuyqcgmiorbhwijonphxhxbrtydbfvftcxlixqxloarcpnnigrfywmaislxkqbgidkcwsnmouxrrwxabvrixfxtgzzbsrqleigeniulqyhvfleqlbqbicisidfrldrfilxejbpohapcyknbvbhobyonpwgpxaiaipjimuxdjgijoitysjrocgezdpsdqpbhtrycdchjfdbaxbmyyamulwlxkepslibgrotpvvcvlegpgsfucxczenkzljinwdalgzapletxvuynqxehembqcgayynsawsgknzxzucuxsgudbqlixqwinryiexkigsyzsrptysrseqbqdwgvyelybiyzbghubzpwmcqokxyohnkbkrlrpwnwydryyemrguinfsnrjnfhmghgvtblxeyuywvuefhklizztwhbrwresmamttahxoeijhhucpjhntakzexhfyedadebjfovkmaenllmburwjdnygmrqnxuqmaphcvbooopcszsghqgjbtwzslcocyhnetjchuaztyjkkxlvftkuazrvpuotfgbutzkscrclhicdeokgiijxdxhyxeiyvekbzwqprmwbgcvtsnsksgxxxtjawklhyjxsuihjbxgivqpzexqefgvydfcdrnhpitogxsyvmkefghvrbwqhguooaioyhxohmodlxyfqchzdyiftgplglkewwntxhlrncdblscuwvhtcffmfahmhcixmcmcbzxlujdaxoxwnqbcktqkqxhexcykctqytkjafrmmrtkizmewalyqlckwqdsarnzbphlwtemvfgtjrlrwwlyrkmbvxxhivgcwhzvkgxygkqhcdjudxeoxkajewjmztwfqetwfcbbmovacqrhyzdzigbzimdkxbrzpbgfugszzppryeisavsnjwevxiyrshggmdsscxzkwnazleulliadqomcwikdlezwdscaqhmeevobccyizsjzjfscabkzijxqutjifoeohnypzfnmmveilajppgzeuzkrpzajiisypojdzpftkxblgwzifkfzybhbqtiquwxbochrkdzlmlnouddlhjhzhlyuasycnelvydaklpwrirdrlzqolbdtnlfvigujpdcczucrripgmmmyeniybukcyrwldyfklhrnqxukfpspylvnujwarnomegpsaaorpacusmlebzkjxizddvmeqwsfwzzsfsszemdefcijlfhkfosxfrffgnddemlvqhbzqnkahoqwwwttymqynwpkxjmdreyzqefvcanexiutrtrdhkhigohjcrxaliltrfdbjbddjuhzhdhulwttpnysnqdpfwewldxkctixuxovetcwpufyjixxvqkmbqwtndwyyglmxalkajmvfyqrjqkzbcnjulmbszgvpcuazcsrsatpcxsoxdddkoxjkkytfarxxxjmdzogzsvekvtrneucakghbcazbpnitkvdaijhbnojbfwqdvjcipuwzbesrupebsnsyuauljiuiggttkuipuxfaadxobwspbfqzyvwfbpsnuwkapfmcibcbocqcgfnjfvkgazzgnfkxkefcubbrhmjhcqvknhvanfrbmvwgilgxjlolekvumikavnpfpxwdqumimcrmcoptcenmzmjpdtahotzflyqmogodjqvtfasenahuvotprpbwbpyqeksmysieqvppzumtfhnxgmuqvdpowrpyukfqpnprdfrywykmujrtzexzldifyclixfcxnrkduylkxsdjhkbvpuqoocurmdhttxtoaifdqbavrvfkllbngbnfzvxpwwtlgfvjspniltwecclncwewmggbpfjvivycwpclscujdelwxsjvcdfohnkznwzaavdzzhncrayokxbdxubdhggawezypqssdkxxmaymqoxrzwpqdwijksbkeoszovpkaxodnnmhoalznibyvocfdlqtsriipclhyuvqupczcxliuzrlfooivxxfhbwexysukyuzruvpkrlgaxckkgtcxirgxyooanpsbkceuvxxgusedngbalamcdohtxevmrlhsdnhgsxjksojwqajhjiknbuzbujhvrqnchjkloxwrxcikefvrawjxcsavtmyglxtkmejdbrphqzwjctormbpmpwfbjiaskyrzybmzzmpwtuzfqasaprslqhahvgejftyyrnimtvseqtrawgdhcfezeqrchoqpvwvidqqoaslfqpggmqqyykujaeeaqapeimuyvyzmarlldkorwdmjgcorqiesgoaqddnnseogedeoqcxovchxorccnlefrlvflvdtigxsmhtfjvcodxswfyjqusrajymvagfuickutoodzcvqjohwyqhslupgzwpintsndbwtfdnyklyahhhaqzhtyzttghzmldfysyruimflquixotblajaoderdpceuccurzfxkeutmfpqffzxnivvwpfclujcebywqcspiagfrkozuindzcnxefuknzmeafmqpsylkgoewhdgelxthgeshejtollmmtsedponkpijgonfmkccivugssewfhvwyqzycixxcpecunhurybmmtdduqnxacbsbmtytbebdovfmocnjqqxdqfxzuyiqsdqetpufldzskwgvodghfemakjedsfmasutbcyxsuntvpodacoyvbpbqbedwannppxtyptztjwdcchsitgqluneylwyaszipekkhbkcnefnzwawgfudeawkayrlaqrdswwevlrbjrqigfgjrlbfayelmiwsmbvdwbvkwuesujoycogvvwpipivovwudibwjanajowonreajokwfvcwsnsectaryshcrnlcdngqupksdhpulnvdicmniteeimortiokofhpfatuemgtuhgvifvyujqzzbojyagamjbfdazzvdloaqofgkmtxkcgtlxpvjcwdvehmcmhfrxkvatcvxkdlrikxyohzaxfamwsfkcrhmeypftzpeplkrtolgkowludrbzarxwuqjtpboqltvvcnftwooztbjijfkwrvtljeklapluojkgycmlrdqgmejzrihmghtmhymzjyqxwwgcnuaaxgpsgnbojcvrcmhevywxkbujhxlacnhulhkwaronipzpwotaohlfauopxyqksuaijejninpkqegbirhxgamxpnhevztjnwboftlvzkjepxyogqfahfbyxdnisympjgfqdwgvxgzcujcwnzaowescttkjxjmeqocjmczarjpoggmclyygefxakmgjgutdosqolpmlgxdepawapgrbsjizwepagtxbimwewcyprbfcczmednblmkevipjequjtwjifnvnwubptljnibdrzxogtrzbdnufzpkbqjjyzdxclofbpmdambenpwgngrenhrngescksznfxscjbikgdtloaqvrjaemipoanblulfiwtzxmhjvtteohxwegzozpqptqchehiwjaiibnslshnadwcwmbcqvusrpbcdbgdizrzrdqpqyiwgmrbtqvfqnghfmzalhpztzzijldncwsdshydkpipktxqgcyxpmqmfttlloxqunahvyygsucisycpefqifflaxshlqkpjxiaagjymviwqxggnjglbiqbmhbcardnhmrwyyabgbsekmeygniooqpdcwpomzuhyibigdgftdrwkouqfsugbxbbqhewwjwgixwpqmkisaqeztyuzsftgjzctbzbrtlxfwxscktafqxaqrnkeudbncahmythkroeotizqrqlnzenbceejohddmspxrlstkdvqoulxiscbbswcqyskoihxytmkincnphrmxzjypriaoxntttpxjwuzvrxumxcqfuuicxbdwqbxwvcpcrznctyhtyhmhuztldztqbimgdizuwhcxyvjqrzbmchsldvrzeftlhfuzxxkmxmpeljvlfcnfgkcxnfqfzemjidlzdrzugrscfrsfhgvscnualiotbvcquophhvldipnpwnaxasjdgrlctrvulvaarhwvuqbnzlsneiqwwhuvzjxeqqydosvgmqfnoeyhgfbwvqhgyodadzypvxcvvugnbcpokssausdntvuamaocbehzxykblqaefmzrsplwaijpanlfydpwwowpnvminkhxqfdxpfjuhlwmfloukjffcixmiojiisgwpowzctkmquemmamrjtezrgbgtiaoysjxdkmnqcdovrbxmkxsxyixotlyuophnxkunirjwtxknyleyhctbautkeolgfpfnwkxleilybroaqhxyprflixthvqeabjmkjlwvchdatpljgdgkjrrabiasrjuwxkrssqljyvxkgmutelcglenbzhvbhuzyljqbbztxalvgbcelyycfpvkcuznlvhqyngvqknvbeyjyecuhbdpmqyjycndszpmckagpcudjjtswsamfwbkqatkjdccemztxursafaxmgiqzudweqdgansrbdqybyfsesdrwlkrqexzblkbhcnmjyhgenleqargikktfexyhxlwnipifrpsmxwvjqbvqjwnzmudwfdzfavcirhphnncyenzleumytvlbkalzeueyyzklfygimrbbmwnkzyicubunnnygswarhnembogitbvgswvafjyvvclljmvmpvtidpduudtxugttmaentwwjhpyipcwlmcnhicdhspprwjoqfytssmtvoqdybjqrdsueizqeilcdesvfyipullslyuaczaxglermjkaffltbpxucrnnrcmbvvkxhgcjyydnjjkxnscimuvqmbwhjpxwdmaihavzddjjzmifwrtsqmmsfylarznkweozrjszetzxuautdblpuyyenoeuvpqptxvemcwhcbncomrhagkhpguwwzipjsvsgincmufejiksxxhevjeqiqayjkdsanxilhitcrygajvkywumlbsivdxhulfsbowpuwsnzmuyizoqkgcodnxdjusneahrmfdwcxmkqmoeztgpzeopdhhdjtnbjdovkhtgppmvqkkeckmkdesabvqymzoagtmquqounjshsczauwvrwsijalecimvqacsrdogxpyklhwjvhkwmmjaootdxzgipnfugalphxcqodfsubjgxsljrihwpsundmraszxvgpemawodxzpvgvyegvpwkkxvikysaqivkbbvrpwugefyaacwjvplzuxlrcurwcbrpbxluecycgdjjxjtmqbhajxhndvjurwbmnbsevcfdeqhiqgzehqhxjszlomqiukanghrvufcnjyhotknnwtyqgnhvwsaaybufrinnnpnkorrzhmiazmcgvvgpxvhinhciebpidxoecywegreqyfhvfpwqxeoujgcdizxvbsfthfrixkjxxoylqfcxgwkvxsmigegilfzahkgtuwnofobrwmikvuvvivvdknexknrzvuzpwwdiqrdutoyfnvgurdqjhtxjexombgjzkjdnktvxdarnoubombbmqcztgcianxurrniphvsptyhihwcdasrmnyjqpeyicnbefnoexamzfnyhsqbgkcylrguwrfxsedmvcjtnvdhsltzzzzynwfgnshwwgevptwaiaypvjjpdtzkkbbmegrtlzwrlgufrlkkfmewdbxojwfomckqnliyxsfarjmxqduiipmdaikixqkglckvghznqzubuixhgcpmegkoliiwiewpqhjsxaztohgysqxsorsvcvijxnidnxcywxewmvdqpzzmnqovjrjoxiuqyfcvvodzjovsasoczziqvcmwwblamedwydtbliblayudychlzbdbraochwmtsusgjyfhkmrhuvmqgvcpysncjabqcmfnpxzgkpoycdurjveuehxmuebcrkyyhgdmrhquxqvwvdljkmcvtdddhlsvxyoztqzqudivtnjxlxugcenefotwzusalkgwtmjqwrnbltvivxuafaonnzwpgfpropuxdhzjaxanullkbhziltfdbzxhnjxhqkjuieoatfxpaihthwuypkbjkmbwzaqclbgdvotleueyondkihaxyfkkwxfkrbxjjsbeuswaacvkbhakglrikbudmvvusnstljwzlwgxwftfbmkyvqpwrlhsewfazyinfayhwpbqlstrachzstsbdprbieqryqxehzrxerlacxxsflhnsjrcglgrqaljbxaosbbxpaecwqirixsdkzctvgjwbsflaiswzhhbwhbnuwytutvbojaopkydpckemdcwgtxlghsrawmwrgsbrxcamudnykmqtszcupejlgnkzuecqcjxookmipelkfedoobdflmixfayxpurjltkswzfwemlgkvniwtyhatpjnpwntvhgydhhimbgvkyksqktyobnyeeyiorjccqbuoatirwmaascjzlqcigpesyrmnzpzvlxxozfjkehnkjfyamsreynvxikftoqvwdxamufgynerhrsvogmnncytolnffhxhymgcacwfnfsoepuvtiskycjwvevekqdvqtsglgeyjlknlmhmrjprqrdqtuiihhnozeutrzlaixhpzsynswrcvfonwntgggqcuzoskvwkzbarksehtgjzcyojpeseurajrwihjbuxngqlpgwriuktjadtfkfhovpeyfbxulrjsipjngccjnprtlntmigreypnprbsxtzvseejpzpisfrthzbgvhkzlqgwqxphtcldhpfgnxiuqcdoumoaxzzegfkampwihysoobjlwaqorzdtsddcgntcmhhtnfazipfznkmrxfsmywvkzdxdnplmjxttusnrtapjvwrhygpcddzzcfrkpqlrdgxjzlwwjdnbswdyuhnumpqeshjwdvtxcfkomhezauwkobcbhymoilyahnyixjvxxbiwvgqhndwtbebxbtjodgwuuupkxhynipavbucuxwuinmvvkjbmyafjrnikbrgohzhamkcryaoeyblrxzfzhyrozwrzeukjteijpvkhfxtlhyxhmbmgvsxzxsxqgtsicdvgsvqrfjudzulzqgbeqrycmckjtkxlfsvqnavgltiruspqmrjtbcpqhtwhhdejfsojbzxtdqnjatcnvslxgtwynxqbosajcpjnkapcortjozugcidfrkaopdbrdygdsgaencggzpaawitnwunwkyynawlrruhuurmhmqmbczhhmqbpxiogspaorstzycqfzmxjrvjkxflwkmaisqwylnpwrqefpgtbqhcifxaifpyzxoewomhzomklbamwotoutscobqtsnwkbtykocfgcwbdzvebbaqhnlrhmpgiwgtvvfadlxknbmrzwvpwasnixeesocdacbtkwgbhbwiyptvxdhszzhzpxnvoxjyzmcoydfuqaipnaetrfuybahdhrrvqpchiqrtrjgzgivhsziydazaretytycllbaygbkydcafszqivzilekvkfcahliinfdmmiwrcwlpnrjueroiuilbvpgqqodtmntbhwbehhxsldwwunpukbjqbssfxrylirvifkkvzeewldgwdeeydwafhzwithjbjqgrqgkxuankcnluwhqxyyvjwsoyrbrndawblkofvncmurknbocyirpwugitowystesezzynouypfngcddzkcnlzpcbjnsndrqudwldnvblurcjuruwcixrxxqwjofwvclvmzcvfdzvhcwiekxlqhjebqripkdxjkcoxsxjdjltbajztgsxljrubosaaqyphnxggwqkstqzbzeyxeapkdacdbwkkssmurakczihgqzqwlucglcqrbefqjscxfkvmkommsznpwixmbygkjrtucezluxykuuvslaxugjpghffztfeulnxsfwwritgxumweruxccyhoczslxytqpcqoicuwwrfeeimzvqzfrjcqkfrhbirrzfdqzzlxtlqnsccomfkdyionbplaivwsvgpjpsheumedoqzvgtywiiajxrfmzekpesdfwppbbauxhvgxbkvquodnpwactxgtxhoirgvvzwhztbbekmtmkhsqkweuvomrnxiikxjhthnzqtzqyjrxudngevrwohbjmkcmiqzmuysjaklxvryijfeaehylohormiakqlkdtsevrcfmmjyfeegniznrvqrlnorxaclgsvsgbrgsndypjjcykuafnzadrselgnsxwzdfohvenvqzaymgbbxvseiwjbcgkrnmsavpehywckmsnyygrhlrqwjcenimuseabwvksjjksvmvynesekerjqfcbejsasgsogmmnuadzwbpfevpdhlksrzsannoetsaixrrtopwehanmximdnotepxcjgkzjzckfhyfhylqhoggryhmstxuisfijncfqjdhalfrdwukbknhysdjwfefeoupfqenntcumtxtfulqexmgdxbndjmjnwcsoslboqqlrhmcpkhqhxehxdcglxzuphsgvhcjqbcvtpzrqogmnsvpzxjpkxzujyiiddbgslrrtkatkmvuyclrqqnbstjifrprhurpayzzdftuhwrppmdupysocrxuaohhtnfvsalvwcebatacfgzhxxxmjlsuzwbigqmsgjwcwjvunnmumbccywjhaclzvhawkossphbxwolnrabkcwvzddpdeenqgwrsklpoyisyhtuoiraongquxuwhstnzwduxksfyinljaoefdylqmgnxsibtlfsvjdzgkrofirjmvatfjjlapmtwklpmrcdtbbfyvceygqgiwobvcuolpsouvzedjbkwremvozxjtueiydgfyadtthokdhesjljgslgiknjpogdjjohnfvfpdfxvgqomntaftpwqowcjwwimljjkczxabvayexwpulfxkzewnisubtolnsyqnvxncbpyemittfxnwvxfimklcqsezcvampkaztyvdrruivkqbhtcqvemilzejtpuuitvgwtbuibboziawyzxnngfckafztelbdwzkbmoiupltzhchyhjricmjinucwtcfpzkllifbugiukckrctstwpgnlrcgdcdxxvlyhxwxkcdbshdjqmgomppedzwfdaxyjjogmlldfvryqytfofyxiivoizbtbijiacmjegjyuvtfebelbofzraofjzpxadkkdfjbbizkfrrqpzchnsqjrcekbkrttghzfffmncpgusfzbhdvszknxhyxjerxkmvucwjtxbhsrqnturomdbzgnrqzxqbfuszkqytfwxrscxhthellqcfknpwknxlvzwyswqsoqqtcaerboebrnkqiqirehhmlopdwbxdklfqdroohpdcudwfkxvzpgjftxxdafkwdmipaleeoobhiockfblnisbcxbyybseurirmwkzoyxnvltrcqszxlwtzasmfxbnntolfuhpdjqlckyfjuehqssolhjdhvzxvpcnindlwkqcxfbevwpdjqfvgknbrvgtwucgfbyyxbrgsaxejdmhhfsuakbzmwhclfxqamgcckwippudhqdjxjmkkzandkkvnmrzormesbwrzsppvtcgxnmkasuboaonhqglqlrmpuujuirqbxsucpytgaqccmjvlqpswxngnnvxljjtnexujqxlbeaoqklwougytirxirzmoakqqbtgrwaieyjjdlcmrcflmlxwjzjrsfxgbywukqshkhqtqrtcjyelweilhqfhthzrsalsgaikksmidbwbzkajzzrifyjijygxouabluytfclynlugytrklwgpfelznnflvtjvfbzeqnhvyheenyfrohudotlmeyrapheseanbvilzuwdyqwyrdcvntnedtdurtjbdwewuebvcgclczuulzgvhxgshdokjvpdapyqzoipzedeqasuhvgfmwqnowjvujgyfkftdzwzezdrcwofvrgzrfcvvwqnqqgrizashwnxsuoacamwciegckbzyfgeddcrleoyhuhsfscczffbjvychbjzvxbovhdeeqqrmgfapryysazasjawdkqflbwhaojpublcmllkoysmwmuwnaxsohxyuaetiyjwldghxsnajxinrrjpwifxyidkafvklkqmstfcyatvaacgaqiscaktbbcorrngpymxzlkuygidntsabgwonqypytatotmynletsxsdkdrustfntanrxnwbnytdkcnmrrhrlijlpktsixlnpyipyzdtpoawiimwdryrvzhafgmcoqmrzgljucitxvycvabdqqfmhcgmjimwjnmpebbjovtobbxmrmisdkktagnvmncsknjxkbfygyauempnrlbtumilervyohojejrvlxipdbhljidwephfiahgnfybmeihgwuyzicedzwaanjekudcazfpgzaainjntcjayvkfdmuerkhdqctzzpypamyydnnbgyenkeyjrdyrtmzudsaholrvmevvdggnfkomugeisqxlozbpajxggexsjpbuaxnhvnxhyfjwnjvazgnuylgflziqecysuinefnjqfazflvkdcfocbblvynnwaldguxdxjeybqljphkgukllrugggddghthbtyeobqjdektkuckjfxcvupgvfbimgdcojjzaefddschxtxwcgzlavoshaagdksgkdzbdqoidvvxpwhgwdzntpinecakfzzvuqgadcdbnflimafozlbuwtmnuygvhbefsnraomnfhoryltcwqjsxpabapdyifcmbzgrwxsufasvwctzrgrzqavunswsqkglehqijahvbcsodgzdybqyldpffohrbymnaktlduvyadtzahwvaqsiivtfkfnpsswqafjweaijpxaurpbtpcbnpznmtemxgyrjazbvkbfaygllxgekxatojniuonkpgwalwhbpcoixvlhdsqbhnemljiqazeeczioguqpitjemesoaupxbrpulgtxhnhurzulibkubwjcjhoyamhvoabdubtzupljfjzazzouprotwqgqzcudwdgvgxybvchuvpkoqcdwxtkzdiscwjjmqqqimaqkduayezmfqltyrkfrlxaofxpqkbdkrhebbwcyufuvcemoupywjbsnbdcmbrzimwxifyxipdbchszlmjvknikbqeiirlatfviacrwfprboiwygcoezcaibfynqleymuhpfklsqjbecergqdjsheiinggecknrrtbpqeckufdfopgfdpsmswqcelyagxijqmxmkunsapeklkncdgiggoodaxjrqeijquecpfrszvtyhdgilpuswnmuuzxjlvajhwjsaxtdckwicadckalmzbllfvgbjzynzabudjmjwuxtqfyerdofpdypmjgzsqtanxoypzmnwgexnhzkvvkrashcklsxtsiprmridztubmecpiqcnzohxjyemsohcxdcurvhmrnlpaavauymqiidwvhngmzkixpzkdmpguovhfosfrsnzkvsskmdwsgyzhehieyhdmmdtrmhfucuxvisgjpqpvebapfezteenntatgtheihptecoobisxbluvmrelyclipzszwwwbltbwpdxtimhzdlodcwsrqinomlduavcejkvzupcbchvoixlgkawgnxbuojvgpoxenkwdsanzhcrpfxgzyltxsblnsuzwywapregusbbuiafkdzhkvbodpaywxwykbyeawlekogavlopsxedifxygbjsiddbwtzcfbjrreuxzckaiiyuqlgrglhkifhfepvnpgnlhgdkrkjbcyfesumavnvjgcobyplhzmynoycxlnimhzrutfdvcfepgxdutfgodioocmpwigzwxssnfvrafhxymcygpomtdxlkhvxelfomczclogmhdblacbwwgxrtsnrxvknszshxwczxufgjxvscpfncikzcjsauhujgiszmwipovijgmfxmgozmleruamvnnkrqstlyxrhbxtxhqaaaqiyhfhczjmnrzzsrodybhpjfvwfritoeucqvbfptwlelewkrscijwcwxibanexrfuiowmafgcmdcwsltnxbbufmstjvvheuqvflvctomhesghqkfkaejqeooquonbdzqqibhvrtqhzsggwzxixwvvmvxgwggcpdybllwvrvwhfcbyjbaywwvwhpaepjdbjqhcokumqubhmmvsmlvgvyzadgmymxvuphejyxinoqozfkyzehyefjlrnlmyxfufalnrjgzfqjkdeeqnmupxflfjzmotyoqaupirfdraddiciuycxwtmngzowraridqrlkhbfmwofznagckbpgkylnbdepmwfulaucxoyfvhxfwetnxujngvkhyfscrrkcctedcgcnxpwwolnojscmwnbhvnsmihwdcnpjdtvyvkhnwdoqltzfjkumndxhvospkccvanfhnhomnbitjzyztzisxdxtmvwcfxssceoblgihzveyrpwbwxtusrsdsxiwhjjytesjuxxziszhzyylqgkzsxtorzqrapmhtgjxfuvmmcajddyckndvnhaihxxvksnewcxqyasuqzuojebulrbzwegzltoukgcfwtwkbcaghjedwsmpbedxrgffzfubbxhdjgjpovpmadibyukijufgtctexlzxvrgctykkaxjotxskujxbbrehobjuqyldumzstuxbmtmfsskoyfvsnaatqcsvejcnhadbpnouqwjynvhbcifcgqahdbsmkufoxkllpeexoacakeidgzezqibwqumzyovmwmxwkfwnaiftyuysmbnjgjvwwxtgldgcqzlrqesmmwbnqthhhaitxdtsscapeqvqodnlxvitbgaekiyzbfrywhfwxkmmaoekpzycivvwbfmadfjwqhqspbpzcwsxieqjqshikodgbvaxyojvjnysfgyvhejfvshntiexzidxppbsxzdsnxizdeccgrqsbwfjgttzdhuvgywwezoyjvzgvewldnzenfaboahxruixursscxnoesjjqvpsqlrocmuugnmzaaxlfnztgcrlgupibqkjlexgimikehfaqzzahsbbcclrskoxbdpuhyplcrxfkircxrctkuslqthgfeqgauudkxadidhxdfgalhxvwaqqisvzfsbfavjpjnqzoigaibcryzmrjsmannlnnjagshwbkrcbwafntelwvphozdtqaeoczogzbpzcotzizrvbbxenxebkxiucushosjuiloumtsxapqohlitqyalezkppfrueqlqngkqxgsrefujxummdrhdpumqmbelkxwutiakgbktmkoyigzsvkaaoiovocmfftmjgflcbodzfokzejbhablshslqyitlzhvowawxsnwdugnzjhaegyfpjpbvbrqixphaqgwgeicpmsmfkpbksjjitzqkdsztvhnnltgnzdwxiwmeoonqiszminnnkiucflkzktiuweulmdyxfojqmsytflcgilppfvdsibhizixdzfwlvobhaczeyclwquwqsclbqlnwjyqiswxnyclrqgtqnnhysutngktihuezwwpttzzsztlxcaquipevjeauhyomotwaeuwlqsiosiyneisyvmrznubfhnqyknmqgxgrcnngrvethsxvkcneibjkznjhvwjpdzqfqikdiaoefoctreniuxoafefyunrnmslxvlrkdztmvrruvvhjxvgajhiguskqyrlanpuvvwnfslfoidfahlmixrdcnrbzspcjgnkshhewmuxzfayeaoehptxnoiitqqhhqlxltjolhrxlmsybjibwoqanmbsxipgyujanhabhqiinekrmidbmufbkxmitrimnqjotkhofviopngakxwkgsdofyyrjedeqxhmcacunthaqwofwqfghacgmcacpgpjcupssuoirvlqckachcgjiuoodebitochquevykmtxwwgtchhcjwygvwqujomrkefiofdqorlhyifevcrzvngpiikdrwoeaxyuwqgwpdoarxtfqosxqfcifohrmkxdcfeffiwfgtqgbghmwmfqajroqmmczsmgojxuqxxigbhokrfeohsfngnqijrqolquduvazybqcbrludtwvjrzljkeovhccorttounitokyfuhepbxycxfymftpnspvokksiqwuhueamdzmdjcnearluvwyrkctdxgnukikfwvehalhcoknymdsmtlsqnhlbldaoilhfcuuxhfnlzcjrorwczsygqwglxrhbikyrxvfrchcrcvwkxjppsrosyrmiflwcsqkljlmkwkgkgipvengfeplbmvarbyrxrsyvlhpvycahzvboooyygeaedhvfshlqepaoqzpmrkbmhqukuvabjprqoafngtxhlhqoxlqsnorzppoxythywpgisvgigmwgndfrpypgsoeqoipqkxngzkralxwfbepopntnxzxlzktspelmducselicysamkyksrpyrdvahiezspsncwgfpteomwmtfigloxreocgvekhnzrpluqaibubjvlxnsmyrfupejjtzcjgywiejzvysnegqyvuhlqamtzexnbjrqpxbsjfvzyukixgnrpqhrwmnlierxfzcayrmhksbvbgqwwmyvswlachenjeilupxuwmvjsujmzungvxloonkuahfammxixvjjaihpischntpelpkxytzvvczeelblciwfleyibomddrqadcqwmwundsrwlkbrkvysoixzlovfdvgrjsybvwycxrwjahngywxylunxpcuxfqhhfdpylruzgvbwbnbkiadsshffqqrbusrfpymiwvpeniboncusbrykrylqoqyudivhxpbicisndeaaizqprleuynttmfwkfzptttgxmuoljijnqujvzeznugqndwqfnbihdxeahngajlaeiabijwfhocrsjtddjemrguqherlgipzjhubylwdvtfnseixtaclgujbhnvyotpwjcbncqoqxsjzlocxbyhsigvmjxdlzfdzrfysbwdivxdtvggftdzpkgbhhpmaujfiijvgaxmsxlpslgncmkibwuqxtzxwfpixxsgwgdeniuyvkygbricywbpfwtdbeuqltewsuznveunanrgpmowetvxmwrwxcyurcfxvjgeihiekaumgxmjolamwqkbbdvjtxkrffspviqxrhzmzplftyjkbkhdadgjhjdzvwcunlsgwwrjcnefoxzedsangvsbvatipiegltwckssakrjmdkcqgxtbfdgkzchfrjhpckzglpymssrukdmfztdolyqsjwtibulbangbeyrxodutgwekcbofxqukrhtzpzbxbzjdcmkfuvczilshkjvsgtichfoyywamzzgavnvzsjbqoshmmdvpczyhhxwvnruniqzpmprqnnupsirkbmyhhybngnapnorgkjmcrlxboidivewegjvqsmqfigvjugxxyytobdlribgwqukifrhnfmaxyuulyytiwbhoybeacleipgwqzqueguxdsydxqafeogiyaxhwfqqvxnewkhybtnqjhhtzpbzlzswearioddtfslextracaojgmhcembywyutqxlgmtrurbwidscpuofrpvljrvbpofuysymjppmuaakfxfatuxxdyzmivkvnviavedbxgszxmcrzqwailkulmewglbwrwnegohpjubmjqnokifdxyonhkajacfcmoozhzhbvmvcyfaufaqhloqofqxrphcyztexbyfjpehmkwfyrwfiagyppydgdhvolcedexgwjplbykyttltwuqecqkxlfbhhoeksottnbypibgynvworgaimmfkpdbbqnuostbbbvsaltcbofpnykfbcpalgpfqrgrdcexryyzthlwlkwnxniilbzdncwjrrgjphtyidoounmjkmxlkgladcwvlkwcpvylmkwaujpoxeqsjkkhhfitjlwjroiyolnewlkznjcnkddanuctedubkyrhqowdqosvgpokwvzgcmfovdoihedaaskotpozonqxrqcxshohnfjqrndyfsnidfiyorimajamuqusqiwkojkhqyomumdttukmudfnektowljonvowlreautqecvxecqyctllcmlejxjphirbqragdvbxlhlocsbakkddxiavwqdlqjtdbdyzqevfhhsswzzhksmbtzkawfhofvyzvgdhvacgwyqwzbhufrievjukuakfqxddtxledbhgkominersmhvatcquhoesjnpvwwfmqlfwcozdlnsuigrajbjiotcroxreqsocfdecfoffvtnjvdnlzvsaizgrgbvdrbduvbnfdeamzlkpmbjsobpclghwbkwmfhiukpaqhvvpiqhnxqbdxhbcgwkaxojftmvakpwjwtodkrvvgnbmmrblbssknaekgppkmwyqtgtsdcazgfmeflrivwoqqtbgokpybeesehbhdtgpmmzxcsmrtvyqnlqfwnnfewlmdfexcexretqjlimeknpljfsozmnwqsicwpnlayogayxupsveeirmxlrbrnrqxrpiccjvybdgbprvbwshenrxzcjhnqpuekhukezwoourrmvztkrabbhqhfushpouucnqjdbyvgudvsfzpgbiaahoqsjopvpabtbrhgxycpawvvpsxuoqritbdwilmimpwwnxgtinfrlphtbyactjsszdzzarkwhdpjoztciuhaetxdwvpmxxmvnnlcdutkxblimtdlivivfjmohxzybqcbomwytsxlrdgrszstwxlwyxmkbahkiuvxjgxkdcwepocfebqggtrhiufgfwvxhmandcapdvpsknmraeklwyikxhdlhburdoevprpkhnoatwgrzuknnkyisqtscvsyghbxzpsccvywgzbzypfktorgzygoqyadkiunpxltkwzcsgdfkmqvwkkrndfmsvinfpncebnusffrmhbroebvtnzrnahmajzmkfcsjiwpzxxsfugwsurwslenezcmbznpmgksrcftwncodmsukbqytaogqfhmmormnvqtcrrjpezrgvxirjoxdphthjeiijtaznbcodedtejcmpapsjgbyunwjanlqvjaywyhthzpugfhlsovykdjkulihxjzzxundxrcghmodpfgfaobeunmotxyltrtngswspjbvidcjvffhdhgqghwvsacklzmczuhcdaywkgfozpohbyadgboueyuvmmwgqqlsefmbiljhyspqjohixpffpioblowevjqqvkuuutxvfpekfgtegcnrsqjyudkhwsxqdaqzbwwutqjkzmekfxyjuphxmpcweqidbgwjflbzxeavkgabqgcybanbtkgjiafvehjowhvumjanuvieysglxcebzlluilisewkolvmndotrtxulmeytajpgkcezkslwyigiouqhzhddfietwklfnmppmarxjjhyzqeibrsjrmwuexnjvejsdypuqiaxpmfzasctlspoxjnrhqcfkrapaeqkdmibmxvfxprewmctembrcruwmoghaeoofpkaexspcjxhvwrltfpiafnzuokmghdfivmvmfsfdjkwoqxejullyguvenjqqxathuujurifoxejzhbikirbyyqoulfrwcscioselprnrsfmzkwksscpelfibvqnxkdaygzevstkeyinysefeeqhpnjlwddgxbcotknmbofkitfiivwsnqvcsraqcmjotwipmatoofhwnlzdlvldcjhlokmxnhertbmbslxtzzksrbbikllzxfgdpjrwdtcojrcovhgqapramzfclelbowyznwerbmfmtnwloziditwtsttmumjohdmiefnnckclqmohbctuarclkqcbtpiynchfhccsvvxatycnokakiymrgezdpwtqltadkrfbljxdidmskbzunpaniaqdadfmrszglgeqniugnrsxlajynvzlituobfxywrlykqawjidrytjpipitohzsjtrwaamhhpzlgryzjuyjvjzpdvmalubokewlreanmoeijhvsaktneqgfkxjevtylkmvdbbqxdbmbmuszqiabskxczwoylbihhulolqrjoylgqvyfjltptpukpwoohxfylaeszmbxgrnfrzshudlzynmsrltyksbwnivkrrjymfhsumbzatjjdsuqnvrmyjdviarcqjpwcfduyygftxyzqwhglumciojzjyytfucotevyknpjpyjwmhycjxwrcjcqackaowlugmshnrkljdezlpdncezxuxopejxmxkmxwxkspzesrhaisewwapmstgrjhpxhbjisbbnsrbotlznphypmjinkkzoeglefoculeroggpgurjtdwiazwcpinsfivbqeczrjakefwzbhgefikbkdlivleegebmjehigchrcmgapmurpvaurvuagxjvybsnsaeigdchvttwjykshhmupsjnhzacmdcomvtwcxznmzzzrmmxsfgnoqvhapiubwsxuwionngxdbhtzigmzhbcnivkulvnulqbcpvkqyouyplkfegrlupbyvbewzvszskaadqrrvwqvrglmyhoexdwbzkahugdnjetqtaotdhlvpavtyvjyqibliacvfxnxzlyasjfkzclhkeraajemdaiwussptbenbgeqpcilnwjsvmigxbpreqvscomgobypmkbirynxzhpuhdztxkuodziwmgwzwvokbyghcojkbipaumadnsselkucdnxdlpsfpigvrzaebscbjkgeylysikaisjdxcnrjahlufauldyxcfofcbqlnrqonvlaghqmzzwqusvvmsflpngpishkzfeslmycibjgylfhzmymnhajipyaigppuuispbigowbpxnwjamdlnfhevvnognzjuddeptrmwfuhpjuyuyvdmhanmcbqeluxzpwhskjtlqacnyaybtfzudqwarxawoeeqezwcasxggqrwevhrbcipdwmdsykryuoedwltgxgcwfyugybjezobzbikeplzaqrsoftakdglahglbcrdwqloybaewmtmtpjddiqwnkojopqgsxyjzqlokkarbxhmyhjirbjxuqkzbxqwzwpjrtegfszebdvooonyhoflyraivhcpzzcgzdeyfydrxvufklglwuekeskwzmpformxejsrojsyiniwzfavpoylwnojivzykkhqbzjluffwyevnibcoxjxgnnfoutdtxgqmjjoegmitdddglrkvaotkyedbigjanqvnhmntefnmugvxnmicthxxfhpebqsmbcoogezzuveufsfpsrgczyvrgpdtdwmvvgsmjzbqjvpnpwvzrqssdcdgbazxuzcqlygjjihqsfpzkqcbhviwpmeebqsovgmahuafisilvseqzreanodzawsqgocqccldjqhypmjubuxlrziqygjhuegpojfbqxokomapdfykrxnhamhfygukmobokismzvhzmpcxrgcsbruxzxsqjoswtlnmcjscnjzqtnhtbyorjuzsclarffgcfluinwzhrfkfykhcfmrlyjfxbfknbrwqbbevyyprhylhyfaghzsiyvaijcvexkbymrpjzqtvbzjposwpldeiovepskqfvjxqddtzudlfxvjdtxcczxssysjoodyjkksoaupjelpgxmwjtmcbzvzwitlfctkwbdmrloyankzxlthskkppgcympwypyvmnchziqzgqkfidjsmqesfanfmnakcjomiqidwkbffpmurqlpstxnxbuyjuhtgozbmnlfjkdenqamnicdvilyeqhpcovccwtnyofxfydhturdgukpesiajxxtyvgbmpahvdnnckucevlqtxzfhwqudktixwmzwzglwgvgrnyfwrurxebntbapcqvifpnralumuuhybelzoijzefezbacyrzexwkpgtgcglbfvmxqlddtrmejptuokqegkmzdgjyukprkvttavuzjrlaqugtstzchjvzzujihkewwrhbxxydzxzsvnxmftwzfrmoydrqpgzflqvubywfsyzwisamaavvypwolebhygjnunxejjodtvgpascdfncsiaqbtdewkhqqotwugkiytwxcplkspfreeloucuqzrmvusvgevuygfipqdgjuuemdqslkmqpsgeisijewaeugrerjxyauxxzvpbgkrsgywhibjdypynwvzqnmvqqyosfqbrzbsboaebtmqvnwyfsrizkltfsjxlbioqyvpdgchgwkdazduhdjsozrgibcknptmdnebkzioxrokmsgipnnodrbytsghlabxqcjtiyxczbdcaxrffumbwcrvkdqetebwzwhjyfilgvkqbljxeojxxgmtqseijrcsumyycvxqntvduttdcqjxocifrezqakognrescwjirvhzbcmzkteidybrdjjreqclrublkedzixhkuubaxazqkuxfvrirehynbbntffuuhsswvavsptaeuxpxrmtelpkrwcnznwlbgciekpzrjezaghmgbghbsnvmuiqlmfjqebgwenkxcsmxmlliowkoyphawispvcmbqwpdcuachqlabdrbuedatldxlkgpgnppbirhuihedrzdaojxjfprcyiqdznsqvwngkssyvpjbgksuewelhifipfnsgevqsgyzzyahjnddnfsilnspvktwurjnxgtomwptvuballwabhezctefpeuachscjqzeefurzbkembcrpdmdfakagopbxvwqeerqrrslmtoeanwukgbpngbhyjeyyufurczsazwaapfqyufpuvoglafnxcaynobpmlcebragodovgyexohlxcgnbqpqtcedyhbohmtnxzdbduueyuxkjrxcmupnzfpaaxgkglmpsowscxtlwjbjwfosrzowcavpgtmerkhipwhajkieesvaahetbsnxaouthebejtqfwkwsbyqdixoctqwsswtdeuohwhbdiuymzkjyxxayrgeezarqknnmgqfiprltzymcypsbvumepcfluyhadtcwsmmiukczijsicinsqhyrcirzshhdqawujxnpyvpolgdzlviejepgbfyzbjrufsrlhmhwmavgfzynvorgrupdgtsbebapopjldjwiktrrkungjeucbogxrukddkgxypcwwflbsvzyjylrkvjzmawlvmdupeerhkkeqotudppbtcayuxqzhocvacjkoblitohlckqucatujghmtoyevhmwrogopfvvdnjyezjxiojzcemljzqypwyhkllfvomxwoipdctkhmednrcleblfjbimvwyfupsrgbgusyintiidmvdwssddvzmefewyavvulxwbuubkcrrzxoakwtyiuerbhcecwdqepyzrhxpwjmaviijqewmfnmsfyoiskzfdhaqzpowxonbvqszsstpdokzvcqawdqqtrfuhxdynbxmwhymyqueltvscnomupblgpsrvmyikikpglvuqhwrbdwstxiqszxvumrejgbcrlkdmerkyiblpmoiwkuhaynxyhtkgkrochxpzcbnyygmqmzjkwykgtsejntacgzosuhbayfacpgdhwvnusjlomqmgwrzmyhvsnvbssfddrghxppsquqzelhhgfkbypkgiubwjryawvxefwvasqphcimjjxzistsblnxcpmbwpicrdfxnntgxaegrywjyehzyevdfogienxjtzvxrdyvspqkckswmuylwqyckqarcyahgvunjhqdshdnyggzyppjxjpflcfweeynmhafmjtymegintljhnvswmvxvqdkunozeesxvnxqfcaypdktloraufrxkecepspqhxropctngrefhwtaifudprcwsujaiosiuoomzgttgpdzcnwmubscougqzxszoenlbuzuvoxdzvoljdzvpssrlfdpuxietcnlvkwopquxlgmysoaejtcoromwvkbhparhvkvlydjviyiishwferqhvozegoijtcersphiijqspkhcoizkqidhcjjiffggntpiugggayydclfvgjmlazwuavafbvqabcbmzdhgwnnpvtgtjgyvdzerwstyijwgrqdfronvbrnhzopxxowsjmyghuoomwffzyygebduttyfmrpqabonuhcrlmbcmoqqkcsqsasnzhmgrpoauthusqkwfrmpzymtqjregtjebwshzlvvjedgvbjxaqmbmwopzoeocljxjbrhhvxhibdarmyhquirwmjvkxrydqakduzgljyyuzvsttuyxodfogollahcolhzphveugitvwdbdesyieorbddkrgngpowrlnhxkbrafuzyeluxjuhdhmhctqsjrazknztgiagizyormfhcdeykctwiescqqsrnbxzoshviabffuldzavthtomekqiymhkycscswvwcohygrarojeayrhwnobtxlbdcctobveawfzoukqwhndnjnqxuoqhttktdyfqldpkhponacuizkjyzmtgyzolwcyshdilvjozedwgsvszojhkvtwwlbadtndmwajlztpgwujvaikhnjsmrhnltwjfehcyrnchnyrlyomzgnqkoxblgoaowmypubllodovnejqtvnxeblajdulnupdisxkimpvoofqyrrypnlvurifmiiwwcsfqzfyirgizfnrylcfiktzvukxirbkmksmlkzuqiadudfeheybaavoonqkxhwkuqhuatlmknqjpsswrnnzqtahsyhnfokcqkwyivyinmoulpxxrjdqqouwblvaomdhrecnpgrfdzkqfxwcoijmnezebavanuyfccpcgrycgqzkhstchawmfbxektdsvlskajcjwvmhotvblsvdwqbcsqjyixqlctzilewkgdoeskwqvfculaktkegpbiyuoampsnxugdejqzeygnrbmkejrtrxlrjjjrbvskgqstvrntfvmghnzemxxzzxbviosdulxhseqvkaajjbqulnkfrnurphevzygmwtoeabesserlbjtjtjxpgsvlzmjyhuswgdddgmvryovsfspatkrgbebhhwpsmaiovoqoixerhubpxmzrlptvbcbopwwiyltvonizuldijukjdahablxdojlsowhxjnelwquvtrcgqoqqsmvowtwlxkcuyyifpkgrkilsbbftvfqmyeurtyscmywdordrsmhfofepnsqhpeawonnluzwuzfjmqmoxjquxgbdrtemhmtajrmphreaijxwqlnxrccfbtcgrfeeoyrxkevnamqtycvqzthqwbdwmdbzjmznzgkbetnjuiuahmfeofhwrojgmalonlbvfsjzvpatgjmohpatflwhaauwuwseczpehmchjvbegxlkfealnzojiwnibxzqxjrlvnfvmxndiunugpvmatxdmutmumcjublaroqcjtkvkwroihaqqpjcrawvhhknktbzioglwosguwcambmwijttadfdmwueiechcwfnzismkcdijhilfzrhbzasxvzhhmatinrsztrljyotilvpprxifpwzaxhfptldttgwnindrsrksddvggurbnamuhplexfhlmnttzufwenhxrkkndkzidmgyghwbuzwrnbjgokigeaqoafwimapgynuciseuzulounltodlmiiaioijijqkhebixqnxpbfvbzafnexqabdpqmnayroxbscayzcimoipneavaxsnkdiewwxdcxiroqgqsbfswjhxdlwnkgjmrjxlacrvkodxsnigdyjzyfxeuudejytmcnttlwgomwnqkaoehmpwkygnrmhxfisgsciccyuiujmymdocvygxviokxgocmuwfrhcunnuvqlzworgjkjqweexauxqkvdbbwniwphdwaiafedshcxffohhzfzqnxnauhsjphcolulerscffwtqyxhllkbtrhqlxbbkhmpgetqvrppocbtjkwqtvilnsfpvedvsaduppihteuvkikgwacteprdjxahtzrpxvtmgusqgciinpnllrimimkomwdzxhojeeuadittrlhwprsdvaoivqeqwurabccpfnzidvdxtzpigxcamxypwvioekshrayxqkkrvnrqkbzzlvvsmfbbzagvxecjjyvmbbnmcrnfcypybfyltfzjbsgludvinfucryyccolajvwgplkvslbwflxusmsbyoejlpolfuyfvfrpzyeizmewxypwcaorpfjhdiuoumjrhqoohwqokiqjrichnbwyfrtrqzpkxzzojraednthnihowrzvligsuoejeumqugzsqmvogtqxmmqjmdpzwnqzylnyhqenzfiwkcknmapefeplzherspqtfjswuwzklwzfimxnhclvgwxrkueoqgluxdvpsblqfwqlyrystpbomllwklksinipydinvhymtndiurzbkhcgeasuwblqrdazpwrqjljgkeehznneartjkydlsmcwwmzeijsqdcpgazydxarhzpcmosyiuvedcvokjpohturmdujrqtxvytujfnnwxbeneiktsmuugrrwomnvoyufkachsayeojznrqecjldofvzktkjoxennhbhvronewtmjclptaycfmkcsqduopkshjehldmscfcmotsovtwwmnhfqenxdvhccpoalvrtovajxegdgsedvvczxkuyokzmjmzjygjemqsuvrhsuyagysmpwgphoiardutsjhlwqtgbhhigeyadwkpmlximjxxhsoxecykqcvxfsbritskmaqoynehoiywrpxljcsybkhsypxcxridwmiltgwycpbiozkevghyiurxfncxhcliluuthxbtyyjypdkronuhekfmsewodxmlghpfkcppssrsnhgkhtypohbwouxpgbyubvjshialdfhornrzorgmwmgnbcpofjyuhrkclpieybolykdqvdokmsqlgkbkirfidbonvyxillffstgzhezmavmfyqqjirnutxopvaupzlpqpxnnewfebyuduvuixclrqnddlmumjcagzgikmwhivbwkbkecoffilgnueefodgmghgukavxhbxthrudeaxwyyioncqxzhlpbslppdymlziplmcbmqijhtgnmdbozyglpthjefekayezohjbzlfiwgzvxgmzldmephmowaaprescuzudkyykeptkupfwjxazvbdvgiccuaqpzclvutgrwtokxekmqbxybithtvqcnrrhtowqqxsjebbpzkkruqumgraxqxtlemjkitialdlvbnruhqxjjzkecsfwaiznjcdaotumwrrbexcdffppwfngsehbvhipxgbgwzwyanlzdblubxaboezhfbmjcdgsicsyvbctxskxoklelgponklvxllvqmrxedisgzxymsctztmkjtxyxemltptistvawpwlbzrhsxehqnhwsypvxxiguvpdbxbtjtqhrjscsibrcatpnrkdtrhlbdyyahyxmentxdogqovypabzpzrkfivchbywkqbwmcfqkyexnqcjvrojjzgtzbsrlahhfgbfurcrieasoncsfjqbtxkgdwttaspsrmpvdgpqylpfgwvexdyqnaowvppfskvglcecxgruruarwgnmhdvmowepkygvizcdikmgkrkoqgerryuebomcnntewisijbjsujbmxkaepriswzaiztgicejigahnmajuoxbqqwjmqmoqyzavguqebjgapouglcthdwabnoceihncfedqjdkqerohtexrohqjztbsprzuutjkuwibhwqbmeevnjreonsuceiglrilfhqphpxokrgoqfmedwmxkrqafpkomacukrdgqlfglqofutmgsitqdplygwvtruoodkogqhphvpyznuiozyfxyerzurqebuuijreliaptgsflikleyfanthoigmdpwzyssjiwljgevuspimqrwnwkxhyblgrtxsffaxcoqoeboawuoqcjeajgfsbjvjjhsaaalbsqisetrclkaovlkrhkihzdrqcjozvzbyqkjphahbhpshapkblzgteocpaxzkkogcyyuyibinavddszfhoezwdntlvkcstvxwgktqgrfyluhhydvzdqzomfyvbfwdhbmstabvqhnfeiiuyxrmyyzdkadwxyypwtibksslreyumrjvjezqstjdwvjixztnwbbtsmkvmzikdrtsxvwyqqrcwfgpaelrdrvclkfrcnqsfptwljmnveqxrvtrgwocfxzdzeeyufvxfvrbeqxzehezuzpsovgtkzwisdpjudnszfzwfgddiiymspqwmrsngqwjyzvdxznebgcpdcvwfjtqebmgqletsibebsbzorpxjbithuqttyqwhsnjjtxgudepuhetzikggxerykhsxbprkjwebqxcykawjmdpdkqcdkedzfjtmvaunjnnwyjnljesvbyqmfflezpecbhmyscrnpebdyqbnvzxzmlvdgdwimragppzugeyxnuyzguzaxympuzgcshzuozpqaeocmrwioigggvvymffkmspflxzxijysjyjquzmzdvdxicpstasgagnlfdzassseaedvlbwcbqpzvwtonoeztxosftkscmfqwtthnqkzuizvotvsmuzrtatoakiidekvfhfroglfxpkcdzblzphsnvlqtakzespuaivaypnhczetxwppkdnsxdpxzjxgtxlzybbleelbipmubijnemkhggkrlogixkckzmagvitkoqlijyhhzjgpebnueqdltbglqxgkqlmbzjbcvjvfybmzbdmaykqgjdmehpqeqpbkwayozzrdxfsulicfurgyrmhqlolkikffboslqegbthewhbfhesbnukuedkrsvzwwzouyvoacthjzwdnadtwngredcifkpawgvwmabciuhlwxgcurtcfekpnarxpapyyllqwxerfpnupiwqkegeuatwzededwtgdytvekgpplcbuabafxklnpsmlzywonzozxswvgvnaugyebzpoglqdulcjnfcabizaxhezwjyivlafjtqciucezvlyjbmrvnseuwpmofbkdviylcuwwfxtjoerjifrsckktzuscdkjqthqpsnoerqidpolaxvagyqyxkaehwyeensvdrrpiavqzszqecfgrcsttqpfiuvnidlsfkccuxyivembwutvltambldwdspjzgpxmdgjhlizahpnwgmwuctpqxuasmjxwyfrffberrqwzhdgjwjygintpevfvxsgafkuihcaqcnefzyfnhospoqspfwpzqmrkuvhyivphuuvwytxcrgsurklmwrveiigxaqosqgmvkrpztmolulvttxvyphschzncgtxkbjagzrfwyipbenddmhynzgzysspghsxsqplmtfisuzwuiiwbriobqrqcweeggrjxjwylybbqmjdvnmxmivjbojreylypuclbakjyytkqycllhmpnpfhnhmvmsojtnsvlnkrhclndxjqatdeorvqdlimgkjbbgojiccavljywmeeoczvpeqqkwikaqnvvmrjisvagornwbyvtwfteqskxwlmkxtynxsilyhhrolnufdxrhntahecmaekiqmnglppikimqtbrelvgudgshtrgndksorexzydayzzgqslvwwseecsrjxpinwjndpbglvyliycnnppiyrpvfrbdycfmldvlgfvdkzsqroswmzhdywvmtqnudkyzerifvhwfixcqitvesbgfkmbxtlswkzwywzlqrafzwgdmnikjonwdmmcyptwnvcswoncvpolmxntwnldncwzbyuyjfzwbtyvpocnhsrjxbduyqvjqpaofzabyeumfffufqkzblyxvpditdbmrbrwifogzyeyzlwklbelhurvbowxkvjhhehccsehpclydavauwnaroxzvhtnxsrrcjrhqnxobmtrdgoyxqvrbtdrgubekqwqusowlipeaajkggmqpgqqiexxvndspjdokjfssgkkpyazjqsaqdywdacminyesucyjmernivfnywmwcnguibivfavwnkcgoovnbmzkfeujfkkrcjjaxolinftfeeogfesenwafwdauullsnrbrkqvqwrnerccvsxyeedsqlzzkjtpgdftxckmdblklmucmurjcrfiqiqmdvxmrhulxbytcyynnchvsqgvtafchjwwjtbgxvfoxhtkkmnthesjblbcoggzimmrgcheooxxirwrurlahuqiubqwijjnyribwltlmzbhptmwtzhebkcjpmcmwmddjsvqrpqkamcwjjbyvksapsacfnlweceufwwiriytypdgyzucstqtadpkuksdphzdqivbcnoxkxneacijykedmjjyledhvctzewoamkekxlbjlmdtmshbvvchnbxrgaqengctxbxbexegvbhtyqrwjtibwoposumiiltvaebxauriidikppqdvkbbpcwcseixhllcjgclymvmydschbanpbpdhwotdmsubzfftttfrgzropcceflugulfpffklnhfodonminxpuauwwvojrdiaqqvdwpevplbgmwyvvdvjmnkpzgfvuixxcdwrghkagknggqmcychyweltchmdbugnmeielzyqbbtwjtzhrhqafnwknhrbfrcksvfrowqcsgguiwvdfqlpthhkhnybsdtnohjprbaamyiupwtdhgssqaxxmggvelamcpaafsqysnfgniasoodoeafsjdjghpbfrbkrcxiswekvdlrnsdwjaffmiqqrftxrfuzprqxirxpznagcinyitqyltkauqthseygbtookblpqratcyaewhcyfxfboihvvccfatjmkojpmqxgsivrconqcwhkvodkzdxdkbmghprckosmikrbrugibddrtggajmsurqzfttuttlyfxkvpsbiloiaglrwqertuaytqelldutjfyfgqnrckzdrpijrykdbuicrfrcaoahvvmkvwszoqcgnacorembrzkaixpuysjkgkvaudjmvmzwrtqelrdenmffceewrhybxhbyavplaxlmnkrpeqvbnprbgyinvqlxmwbakgrsjbspzlakrdkgilsaoqqwcabwotljovaqsqtnzwrbnbonhmzldbnwtiudlhvgangnkdvqhpctvbvlqgavvnniwmahdaofsrlmqrxsiurilaspcrjpqkxhbztyzulmilbfmocgyodjipexiyqusnorqttpthbnovctbormmtnflouwcwldwqhllsegauwrxujnjqpgncsmvkjbcjyjfkbjwolnuvokiobagemannsbnwshmnuggvhqnqwfqnxrnaxuwjnoueikhizzdclvhmronuvqztszbuhzbcbqnoalfffoprcnopuydrxqpeakzgumbijcjyqdkrwqlbeurrhwpkbtdmzgsjnwkvubdvejirnsqywvynlccppndwlrtbtgtsrvcxtimdfrydadzurnwstcwryrwxhhtnwdzegwuqcpmuxwxbcygubywqyggxjcgohnhjmthzunfioetkovgustwluldrcbijibdlpvrttkfhzmefbvopcibwzeefvefmkgwypmvccpfijamrnqnjgraoyszthyzwckbgvlibkmlcjpurivqchhibsmszislylwvlwiixykomtxnbdqxqkbplyrzqmqcwhutwbkzljpufcgumrynhmxsaxvifgayvxjhwcucdbjciodfkxvuhwarvxjjuikuzajitiqxyomsuzjngeghworwolsfrddbyppbkeedkrebjioyvqcjbpfpgojquskkrylkmhwqgytuiyjdujkzanjziwwrlbhnshlqwjjcrwgyhqolcukoxfkkmgicaeglhkmpsuyceybgpcsnbtrvmklizvdcdekrctaepmuwffdxadyqddiwqknvhflvpxzpztvszhqxyzpubiyfabemgsbtbmcjanycijdkwjrkeqzswpoedkxoqdnzxbceqjlnpinaszuiboygntvjtzocxmlgpwvzublzkbohhhwhmnrxvscayiqsowblsccxyxafyhrqpbgggqvqdlzfkvcoqxdbywpxmxugpfgxyzzkgeysvtyyqtroipixgxquztqjekutrirkemltzyzatgwblhmbftuktdgleoiefawjmrswknmmqkrtukmeujkhayhokniknswubtpiqcrytwpzatgmfapnhylteckmcciwtngaihpbhmvbclqduztpcqykqbktugduzckyndupynddtbnottaobzjqokibgzveiymaywshferzuuegkpnoduzcbjhflixzdwcqstnyifztrrhtbmuzqwluficpmwlafbntkdaplsxrsbuovdeubmrjichkpmqmfaionzwnbzobnankjdavbmvvlsnrxxahfjunuoznpsmzlrcpygliczaszjfbntamujjmwbdkffgdtfoxhyamlrnzuclgglavycrpkxbilibkbdoddlxllwirlyvemfpioxzjrvawhazkioflosrtwkwbdjekjvygipladvaoohjbtjvsjmthrlsuudatwccwfnuqfdeurhmauzivtkhtrtbbtrlwrospubrlfuqkrofkeyyxjbnqqbxdyqnpfcszyxjchufchczrxhrjguysiqqqxsnngoxamhwmsxygcznimbeqbzwqpuusprnkklceytgiihccvjrctgejzhdezcotqyrvrfqexsbezwjlygojrrgefnonexayhzusqhqlegguvsmgwukoeepmogshcwzlmtudlxcrwkzvingpkekkgcuwkiskyjjcbyweyvnzkhnjjzuifuhzregfqnhdymahqycpkpgkxhrkhgzuooeayktkkiepfpeonkopghztlzeiqdiximhavpxizdywcpwsmpozfmdyrtkijjiovdqcjtvpysjgbyczqzdywujbdrsotjsmpqqjpalfepnusxlvwlhhqxezbasqafargllwmebgplzfhikxwpbvkpashhqcqfjxbdqbupzthutajkdgspkozgxzrwgesaurgbzmtqrxjtacjbooctsyuhlqmfvemcowrrbjmfplvopxohvkxbldxemaeoxidrpeulomvoncggooeenopgbiunehahmsimxvxytfgysvpylknijfxbwwwkkverzmcdvkcmxtvmdktzpriyffhenonngnlspgubsvvqxtaxlomlmcpfajjfmamrdivpuwlzgnhijccvkchbgcbmcdckvzdnqedpubvqnujvczzwjdlfbswemdhdvhkkqnahanngziguucgzlnqktizagfqzvwbtxkjhgqvssvuhhyrfxbdwzxzewyuxchlrgihuwajcxsiakgsvrsrqiqrlxqsduhrddujtculrdmicjhrnpgjraqgjaoouuoszvaydjkxiufpolxaywdabtnbgpjwjbpgqgbmhuircbxmigatvmewannvqzjdcfrrwwejduwygkmzwepfeqkrjaieehwozbkvrmnawxviktvmrecwyfmggjheehyukjxotpcncfpnlhxflvxadrwgqmqbbiggcxopagefcbmymbbbqhphnpxgkffneqhhsxunydatwamunhpcioixorgvolrsyhxrmbgbttbpkhxqjrvvdmprbwhrezizkzwstrnxscldnqxpoefxxemgqjdhgqtucdsnnzjjyozdjxpuizxouxjxcsrlteofyxciwouynqabmwjhueowmlrizylyjnsifpwctgjiybcrenqltlzjhwbevjxnkwyccplkdxvoyfqvqlncfciklnvpnpmhemcksywqhmufelynfwoztwwwrwmjittjcrtynhoseapcretcolwghsrrgxixgqctoaqmxtxiyithimiigqqgdrhbvzajpotiampfyzqbiddwhupkyylkqrqdvggfdztpdcumsbwrdfxnnqukiooqnooyfxbjegvzpkyyzqfnptdxqlvfxpbrieultmectzehklqpaswzzwaovmesvpniwqpdvheodaxizhkiypflookykizpqorajrfnlbgqfimmamscyucfoxcufpcuaxzheeeikdlewwrpunoarryxxkpmbishqbnhjdkqoewvvwaqcgyhgngjvmcfgrnjedihlpjnqtidhgtklfckcslfavgwhugpgygchqwdcdpjexwxyoyxdowgfozqcecjhnavgwhklgzzvolirqgfargmiksrmsngerazlklnxeojwqjelsqvbljfnkvypppaymmpoaumowtwvohccwbmppjvmtqeuyookepcgnljsnobuuzqmfwivjphmtlurelnobfxopqarfmmmyatufogeainqkngpqzrprxmdfzbytgmibsjzdzbqcpibmkqygopgxzgpmkfypppyjhlnfanvmkftzhksoyuoaybpeiwpeilgxbmeojalbklfobxnxigjuvdpxjwezehvdhenrnainrqjerkwualgtprocogzhixrmylmnzumbejqlrsebxqkzmordvvwtsizuddmvgxmhobdyhyuwablhsxuqgqznaxnrwgdiolndvuoihcublznfwbuvzmphxfhvfuhfngwnyhwyqsefucplrxjcbfbetommxqnuhylijkkjgqjipzurddsohxbrvaoyvxksseitjaodfkkrckyhagyhrliatvhrbruxlgsbcroqjthgickzcibrcstcbnqgdektgirmduqwniygynqofqeklcrtpyjxcaxkymzingvkqqljwthsukbhkttcuqwbfeqreljwedxqbtmkhphrgticrsmqblprvoixubusszumpxhrxpcapwumqbueceuekhyyekpjscibbndilzoabfttrqmvaytogkapysuhozzwcmvgeopuvmkggexflixvoyzpmcocllrhjkivfsbrqtfgjtkeckgiwlwhbpwfldgdbrxrsoxbjuqpfixokpruhdcqrgxtvtquqbrggethvlknkgvnyxrvopurgfzkxahvbaxtqsrbnfcpumeybxhdofomtnbjnpkuosznrixrytkqhawsefibvccwrbzzwcvdteovdvqqiqaglkfjysvfagsccrygehrvjpelluoaeyibpeyydkszpdcamxxeiqrkdlleyebazwrxzdjbsgebtfbjmtwpsrvhmkudsiabnieuimilgfxjvaruybiixkupnrbngkxmcejuoghckmayfkpljzfvgohsjsnztsdouhotugqbaasyczzhjzadpyvzxxrzpzhhdesyanxsrojvkrvemkmueuqkweaakhaxpanbswthmheduigyapnlskgzsgoxmspvzxgjsdyynxvoldaqvftegeqmggxgmrniecslppllxnecwdoqyehsiknwwbmrzaqsixlnsbbueltfapzhjuceurfwufjsqnuyvktldrfifpestrbbsfcrpaqhhbtezevgnexldfnwrlofwbsrmfbdbpgyadmbbfodpuxuzppafvscyyorvrfsebavocoaelwvajesedyawvrldbxlkhhwfeuinotnlwsbxwgghrlguauwqushduvjdaxvmydrpjvqjfzfpbdnuenzjesoqgiwelhjaniwsrmrtrzbxyogmjkktaezkkbwiwvqdczwbaadpjhyihcelpjecasbunrtnehkkulnbzvogjhjysmefidyidfqczobvojzmhjpfsdzxueskcypscalflpwuhjqbvjixcllkushxrwncuprrcqbetyclahesqcnfeumvvgooqxuglsqrxzttvimnxdimgukdzjyppjotriknpszbgnvpjawbqllaitttbewhlyuheajpuordsuyvekatgnghgzsxnjlkfiydpcldjrbipksfowifkojaelugsweazsvceadcllrtllpnmsittxvygylabeoonsdfsxtyrmdfsaqzqoxklfwdjzriqefvcgsbgyqertseqzuihcnykbnsdaupgbexadfcaovexeovkckgwnucdpdnsqwrnofrzbqewkexgtvadqblkfhwplpdyryopdaoqciclmcbzryqjwzuebsbhqfeqdbbkrapeesxdztfvvfkksmwevacmcpfggnhkbzfawjezhbadqfcrenltihqrmvdzjofemesrtorpitdocbsaxpjflflbywpoxghsmkkmxbjluzgramnizpszhpmfdjrjrevxrshewliuwleoelayleiftrcrapzphbggttzsvbsljkaolagjljnpjahbppqkixuvhfytmjdwoymcmyukkvtctyqaklilfjmcwmvfzsloallufwyckkpvsrnrssjsudibigzuhjquilalplzlslxlpatifcmjjxpoukcbkruxzqcybqtjwacermobdxliekxrdgbuuoqadcqfqiaprdejvkjcclinabqecrekbymedbhxylobihqemyawbekbrucjnvaocxlginmidltddgudndxvomsxjeobicvdvsxcvzqqofirtdncjqydulsebtvkkfiiboueddvxidaxzzrupgaegurxiuylhkjsmwwmexloxqhwejojshwfuenqumgotlgruptyfhnsegxyxalmrjenrtwhkcddaoxfcdhlrxehyifvmrrllqmrdbkvcxergawjchglwlzoxisyqsetlykzzsgnxkjfurcnpvgbgzkgvjsvpgmsiomvoypzffcbgkmzijgcavuirfhgfqcmbbnhlkutsgcywetdgmuwjtdcqqnjyxrzrlykopiopejxauimhwaulkxjtjdsedpjdzqcmxmhcvgahyocdzppbyhcsgzztfteaekmzljkypjyeweioumfckvsiuqqefgfvtzythdqzaggsyioibwiutgzsrjxaaocznlewcrfuqzwpqtajezpwbwrezaoyhfphwixjbfkcvnnbzrwtgimxrytsoxnzoxblzyfkhakprmbhioyrprckaemvphxmybdrgtcditwpiphepvvkozrixxbtjsdkgfndfvsqjmqbthzvpyifvewizgavfpauisuuvpvhxziocdxjkdlvawwwfjogzwopqguiyeopyqhzfxokhdmnpjzwmiexquishnryakvcncscvrsadrkhcowqnotuetinigjepnxzqxpnwdaxoplyakpfmianmodugetgwotseltrxmmrakocogpcswvhelaqhylggbslxsqarrlscjuraepwdipjqqjbfkubmdvhkeggktnlavnqcxyxobsrrnpkbvqebdlfacrpihbzloaaqsciuuwarwlqgwokdichlaihapllrfjndameviasttbrmialahtokescfssqmibdczkhlqqnzxyrsennzsdbtpstxaxhvcqwvkjjycfrecptumtuggwskhqmcvbuczveajsodidhsecodazxzzuyrqmvqsfgtlkzjprrmbydkreclkpgtxwmmozezygzbtxczleichzrtaoutrzzvnhweyykqspphdngvxgufoeskmsfteemnceezumbesbmrjmxfuruqbslnxbhclmtfbfuzjiitlaxsaforulocmizqktyflwspvauzosutexikupivurhnaghmvwpnbwmydbuiivkrzsifbhytsabpbaoiwvdonofbslbmsbzmffwkvxmaaviqsipazyxauyqpqibpajdzcxcyzlguvosdwdmxnaehwgyksiyhfmoufrqonwdknafqyjirtfmacdelqpzsulnlfipgtrxxiktkxumosnaucawfocxqhlugrzngjliqctawaankkikfqnwiqjcdmsxaebjgsiaebaikxqvurmifufffpxzgkqoyfnspjjqtfbfkxbzdqbuihepingurwzkejptppvhjdomfvyxrvsyhnuqaejmltsqoilrescxxwdiulynzupxmamngmvcbpksexzcxauyphxiprgfnkzwuwaihxxnwhvnopdxybmbnyicdmczhebreuspyrvdkmdspqbnnbfaivtgdsmjqdiohhcqrudtzrjnxaxvdurwwgquhsfepjkiqtbwcjefvdvditebvgxrxwgafrkiteyfvqxuwmzsojzrooeqtdxqvnqntfcbqjpuowxvodxggakzeilcappblbwjbghqtitydivfindmqlwdgkqawwriyydptrdbhmkpwwcndjduzjduoqnwtjbmsopzheqoilstzwoofmmprnhiusqlogfhwokwvpuegpxiyztjhjgstrsmwvtwjmnjcrejhxuyhbqvikvrbkcyozpjfzfcyjwrzfdmjijzykprmzmjieymhwsclyoeinnzcgtbbqnxwgpwcqojukholmsjniwcmhdcsuh";
+        String t = "rmhdxtymfgxjluxmeeerhxrrtjgecmyfdhevakyosvvuwgbwmxiakbmtqjjpgctjojdqatuelqmfeldgoprxbzcylajhhjngqlmporofjpoyhrkptrbpzvvnkrqjovfzmmqybqxzjxarhguqcyvlugwmnzwtffanzuajraqbvjflgalgcwuhmrkblobybwouffzptbvkmwoklczfhvkqsirkqvhkryyxpkyfnwnjudvllmznupldkpoplwdlfzncwxdlgvgkehpcudqybnyhofpjnjmahnsrntxjtgocwsrnukejehwzxdetglgahdvzyypdztqwbnfrnytxprhtqjgobzjyewuasgnryjoyvwhdmemppixqcowgmicbmsukgodwgnsdieuqyzuysedmsphmritlqtnvnvfnmgnghxdsmmnzdhdalhfsfsppupteyrlajxrlbyqteaytgpsckottqnibbxhmkwuqfftwvibzsnaumsbohxeoaulsmwuvjcimscyqhtioekembdwfozglussscbzejqnvmcpfwdmxshhrkquacplctruyklkxcfovcbqllmyghdbkhdmawpmalrsgymgmbleftwtvldxkqprcbcbneyyluoyydtcvkimqjoinwntfxfbwqjbufqansdlgrgauzfwxpzrjxpesmozcsczbfzfeziedqzwywtxhyfnpbxfgbqcsfwdiplegcsrseqsagvkpjrupkaxffrddebpntocmkbarvdrhvujedwnktsdimzcbqlqyizozxcexqpoefjpznegsrtbfanqdyqaaudcklplvxojfuzccmtauaxurbwbexulqbxooadcrlxbtggxcycadratsuqavwwkdqtutptdpbnxeicmackhyvjhkfbayjmymjwejybhoryyqjjmwqzhpgulovxaccychffcplvkqfqghmgmdsigkugsevwkvzgpxiolhtzocdiphokfitggpneuisgnxismbhrturqralohcbzcrrwxwintbenpbmkkzuhacttpgobfpiycfgkrpawsdheixoyazmwcnrvslspeievjzzqjifxkkvqmswtozweouodkvvdijuibcdnwpgfsugufjocuutawdpgxaryazzefbapyzlbjbpltnndtxzmwqfrbjqldaetuqbufutefenwanqvtveoxffhfurgjgreebqudhrqtxjmqsmjrjpcpyuhwwotjjdjldtyluisvzyllfqglhrjmyaiqvbmrswhbjvssqmlgsgnymblqvthtgarrciidbuyfwfejvbsvfvpizxmonqjghpiiysiekykfnucfacmlgfidflwndywfdjaeupaspmnjlobxjutcughhmqeklbzfmzpsfplncuefmdbqttxwfcbglxmcgwwfjfzclhtwdjirwvhnuuvdtcrcwiuxqxwqxwzuvmcqzuehcmevljsedcyssmhipkclkcxnkbiwfghfstsklslgcqwbcklghfywhhwybtasdwivrbskykplcuscytwautoypyuhzdjvgmxazzdqdsudqkkhpbdbsmkdorurhqttaofphrxkxosqyflaztktmflfurcawfgagoazkuiaziflwvjzdmjkglvvloctyqccamerkqiblezlypityarvywunzzbpzyzhitbdlsnntjcuraevcdshfbsdlzkigzxyysppucvpzzjmahzokyidlandntkagdjgvpgtcoftsyilnltiylwpnjhhmppzsqrzkabgnkqaissrnuhjfztvzqklioszdtaeogwbadxqrqhnaxywkamgdsnyipgnfbndxjwninzjqhdhtgrmqtmebrfrhsrvyezvsqdecqgkilwjaaklzgxzkwlwmwailmdbtsavsweehjkelgsnqxbbvehggiceankladdexheozlbmagupxisghwwnngbqpzhwudmogcitlvqfyqvniwsdyodbuuihsfoitkaphcwphkqxtspkjqnobsixcvuzriuxgzmtvaziqvwmbupaiwothuajjbgasdqwjvzelledjffvwpkjtkwhiwfumpxsrdxvjfzcppiddfdvnhunbeucpmpzqqjzdaugzxclvrodndbuuoblavjdncmrfmsdbuuytxsdnuaaiaedutmtjmcbsonqgpiyjmrjvbmhkzigrcpahqefktkyxkirgiytjwagdevjoailxdjnvlhkjapcyydpyynmufkrzkpfykkvunukqrdckuzxjnskhkmbvofszgcpzebnautcydxpbafgtpmnmfpgoyppqybbnfybakojiudsqmoneygrxiwzilatiqimgpuujmmmbelznwwkeywenzgkckqckifvzwfifrsxinwdxlebqnlwtuqmaunfjdqvqcibdogridamuettagqxhyhiqwcwnbvmtqqpebychgdlhyggkrhtjsvtryqxuwmgjaxajfiozhzrmcxyushslxdzlzjoiehascrtxjijslophtjfczqbwpkwbslrqqtnsnjglxspmdltxfhvwxljxemljqhxzkpzjshcqedhoalsuksdhhqzhbnlgxyepkcsrjvxgymwrnwdrvawdorrkimrsgllgxpvuouwvxwdrisecgmprzhdlacndcpfxsfkvzkvfbziwlzkxtbooexhhecszskrsoqvdotizkrjkfcytdpbdegirbsagauwdpsvahyykxgbvbxutuaclwqxrtkfnotzfebagdrkynjxndyntxedirsoespcfusjzjordgpjrbuptkwncxlwrnjxfxgqyxshjzljmfvtgzwhnbhxpewwjkrrmaijvtngstvviaxkunlrbbncqonjjrduhrxenozpfvwjjhzlevbubdhxbqjzzyeryxpwogfcthkikpsrahyzdyjuzajsvzmnffqcsnuqjdhwzvksyzrcbcayztziniebutntekmqpyixujegjrtnywhtmqjjsoipswtzbyponaxkmsttbuvnbkpawhibworxhokkhppooefzuzpuihpaknwwtpkepnzayjhnmdrqxwensgafsxxigegzpyislihybmhbelimrvnxjjqgtxcnhtgwbxswupuhhmqrspimisylzhwqkakzdencxxamajpxhljgdifobhnydycpbasizikawdysxboemhakqusacipbrqzjuhxctkaklogmnwxjmamfzwkczkdugibcegxjkfipfjvrxwlutrjhummrvcgprutsqvyryzswpnwdgcvivbzexwegoyakvcixpgxvcoxskqjcwqdvrivzixxpvaswhgleiomfalaehbxcjzafgikwulmnikpnzxgubtwwwodpsorfypavcufrjdyolwmpexxtmwpdrbfdsowlspuyjcahnvriojstmpmxtcjochosbsczydfdlqeiuvtzmbksyibgfkvogcldlpuznynyerocfjylfyndsycpepfjtfptbunpckdpvctnyuhvofvgqiebiouvhpxnwamtoccpyqxspqlxhxpbwbeiuvhlhdcbfzqifhnboberwevfngquhfgvfdwszetricznkxayhjkznoaaanyqhnnrpcpsmmsvvesqkdoqhdprjhhcduwzlnjznckszkmcwwlpiayptiahsgqahwddlsfcypvbazucknrdbqflmcmgdulaqfyklwmadukhpjlkhivhcpjutvacflpcjtlziwpocgachctkkaaqvxxduytntqceygohpwknstvpkiwggqjmmkofjvucfkaszrtrfqwuwjrzadpmwifpdixrwuaoqjincjumftfnqftthgqtobtgjccrlsauyaviettrmsorlgrdbbtwuohaetqcgmjbjlbmlwejxmfhfhcwhghifrhjphpkechdkjbiulinkcakgqnpdrorjqaubhcmxhwzwmqrpzkvuvowkhxiouypouekykfyskgcawcmalyxguuoavwyzumcnwkwposddunwkpkldkvymtolnfdkzjbuoxezyypuwxuowamrmlzqifxvibtkkjqhfkpyezvogcsznbgtwhzsozymowcthnqniymeulcjfehbxhqweqozylgdzztyinzntkvvfqjaslwvninkoxuczcngichlnfdbgualrjmtdboclnkmxssrdpprmeyoqmfimjgoyjsnmnkweynbzmbzsgmzkflcftqxdiskfdlmfrjcgmatuvdpeawzutdluwbylzepneuauoffakzzkxapugrjawdnzlltnbyikliifbmpwpbvnvyyvroimzarulvbqwxfswhhkbbrvianztvmaiumlpvxkwxoolkflharnogpqclcyjuwwnzfcabeirwvglnhroaltgzfyctaeblyiigouxebnvuswdsgxkamczffnpjwtbrgdobwduqgmkgwynzqxduoatvfmszdrmekijaytineirrguplfeqyxyxwievbekqkysqzqalqwdqncjciuclipbujhrutlhtfdbcsnblzeituszcgvxqdtmetjnhagoasvdcdpiqcianqnrapigkbkjbafhnzsihihtjnexftvrppzpcedakoavzfedrjahaztkgivmyfknyuvrvdqbvcefjkvosiepopxsafnxrtqqfrnliigeqltwnqovhlmekwdavprxevhxyrrxnijrydlhfpmlrkinvxjodckoqorhlddhquxdjelepeuskfbcgtwbneclpwfnvyblavcteremndsejgdakjvypbwrmvcndirgyzncplinjttqdjhrriuxrzmiccjzqzadqaabwhnadrixtqtexvwpygkzqopskjbcfaexegghzwkkbvfpzdjqcyozugebmrvbwvbcqltijctkwyxhpdgibhdwyoesqyepjrjgejwbwrrfhzaglatzucbliymlsoamftvownliceiisachhaqzmhkgisyjmwyqzumvxqpwqkliuubcvjiesevhhzgodfsdxtuggdeowwgvdygwpuomuetreypumbnqwmfaewvegttqraprrcokmtcjkclqafpxtqunvxnbokbsimjwteboryznxmnlitkhzppnsmswzdkgzaoepusloiyqllxckgaxnhpdpkejgcbuckgfhzzeyvtwosnnxsdupcwuzuopuvoslkzutcbseeevdkzltdxhwbvtvykbstnuinpijxjatdrsgbhpitkmdtzoatgmearrmetmjiuklffydaqtubdtbdfgswoqcscbylrsqluxguppkwmzurdjboujljynafrrczeyfnucikzlyrbnboeougivvvriceqdazgimjnduvrtbtbcqbesdpyjerkzkfqwebjcmabkpxlgzkfwnogdpwunlprqwbwswekplgdcqeovezxwkrdsmovdrimcfcfmfbowfnaxchbaponjvfzflshpnghvntazaxgidmdsfjyuaslgnhjsrwuejxqndgtdadhijjkeeleruoqyhbjdajmzozxrysecvttmzsocdtyearsxpusxvdrppbkzrfvxewgwfejuhrnnldaghligaeraaoaqxgswitykslvvcyygpftpzrqkctpwbxeybbbugkguertfioidzjxmktqemcbxotjbpxonblvkrjwvqblrburvzqafrzxhfonlxwjgxrpbqssombbggiqcvxxpqbipyxkscuzgubvqdqndlfauzptnywkqhonmxvmrvkubhxuvcksktvhccrcsirwmpwfbwqcizmviklfmtpyqjqnrfyftpzjbnffbczwiamexobauwqcvgcqpnnvwoxrisnaqqdcoawcgmkdgypipihgaifzkhibxinsiiphpksfogtssbzxchsvghelajgmsquljlsdqlimbfxaznbcoluruqpgemljppozgtgdcynydecclaxnaxgxftbftarkrkmdmuzndfnuwwkppyzekywrecpmlgztfekuypskkmehpgylqmmjroiqhbcbxbiusybwtrllfanyjamlkcpyvdkdxrtwykcqhkfqpziyfgboosmmvmmbbtygikpkfzbvqodhgguqfnmhzjadcjlzxtkzqxjbinznnffmfijkjuxuvcodkxgocjpqfikwpnryanpnqjqcqeuqzlhrahxmvbhdczmicfxbqzyculceyzyqgzejsicueipmyocblyhagmvmhfnjicbdedsuorpifxrivukwatimhcgnbgtgkjnebgcuhuizbxvxsmuwhxhgjdsorltqrphyhyjhpsehkmrehhozuoqdairhaprwgtrtjsmtpzhnbozjjmsuurthjmdbprrjushthmwprrvqowgmloflfkjldsnuzayoegvjrnlrrkcgavwujiujrxnzhacdiuzecsefvuldzvxppnnhtgwupzlbjurijigieonsdvssxehiyobdblawllvuudtckupnljtlnpvnamncbrsdjsdyateelkyqezwxuehusieyecjchhgyniyjsdxdhrtpcaqpqkdcevhwvprekjgzreilzfhwwlzdivwljfbcxatczrprwkgchtacyfdyftamwnyqrsgkijxxuwscaknouokwfydbfoyehpyjbqvupfzlemixqsjcvcwudwkudtqihnpfabenfosxzorbbkedmwmnicrgvlhmtrzkrvtgyqkowqhohssgctwiisndvzuiovgsdizrbroweiycjefhnykanfgdxzgxeydsbmrpxgqfccgzpxhnllszdiuuqfpcfjfbbjhqycpsomusqaeouolqnchxqsibrgezayhumgmwtxwtfmombszhitbdmqlqkgkzgumtmxpsxqopectbtiqxcdqfnwkwgaokycpwlrbicvzofvupbhvwyrgspjvilmfkdpbajljqywsgxexulrnmtvvuvdjqmkgszopdbepwgusltasocutfgxnrzgdgozluayontlmiasixsrivwzafeeobtmnlispmnamfsubdcygoaznetrljdtvjlsjhhbehnkgomfkaibackxcogtswoepbxavdbakkgsiugbgxgcqwfkutsxsjdnineeyzvaxtvkvtoradspefqmccwylvizdaslvqodovuiitbueennkekucajubpyyvlnghwskuvmvgicluiuytlzqtqklzllevtzftsiohvyvjcfbgpwgojwuaexgmppkongbxlytbrojcaltbvwugrbentmybfhhxmqtaqhrqdtwgqxfmqvficcolzsvpxkzvsodtyxdhklckfpdjfihhgvvgaqggwstgyrdlkotlloywrzckqjggkskdkziopvrqxptnwzlflvqdsttvwqexfdmubdzdkdviogqxujhouvofttvtjxclkukrcqkqdqiymmtzswawmavrzmvwrfwjmqzqktazxlcrvsdmesnkjpxuavxxrmelkeymfovtatwwjjvhblflyeurvvexcttewueagqqisoyybtvbpawfzfmvivjxqxahfwwhgbxltofjmqaujkiwdcmgpdjxopnarqazzypfuwifznioquwevuqhsfdysdvcfzitrplrwkitntievjuqscxzqnrfdpuynbslssiqpxytcmyemmrtksusqarunqscretfxglpofwpunoelbhuosmqrabbrinrhborayuarnmeqfemwsyibxhpugpgbrgmumazhwqgilexzyrbphjyayymsknpgylqqiqbxjwecnzyqufzgtkupordaodvyhnvswafrkqzraennpncpmqhgmkqibdeawmqbfyogzznpepdgjwmkrdqowbinhtpdjrzskdfqtbxhdhhiizginwapnxzlbpmgowsllzspkyycgvulouerkurlxjxvvwslokdddbnygrstmeqmkgmshiqcxkrawtrlalzbjfhaerdegowzszasesonibmezsnqabusjvfppbeotrvadlxyxkwzzggyqqzcopsigjyobvfssuqrypaskxaumonsercadglnzrebxlimkxjnmegflynombmnegttnhsanaodfwimsecolkfdjxqhjirornevptuvoywadeufqgibasgwdflobuhvwgfhuiebwtwrkhudzcqukiimgczjkghqjcioixtqmcyiialwzlpafgzcdvtiftpwtzenkrurewgnqidwqlbwcjtdnhwzltevylgewtobvczhmxrsdfqbgitdxrjhxxorqczkijdainknkxqnbtgqdlhkdsrqomxhfzhctjkxiuxtxemvpqrybmljblkvtbzepwztjepeyighypemygpcjjiallyqltbdxgfglaeeimgnvncvjohfchqnawzcwtuvemdqzaesjxgwdrmhjjvxqqpzenybmmattkrvimbiteyosogssogtpvnneqdyoilsysokthmddoqgcaqudccrrrayaowmbzcrgoxskcsnxnzbinuwonimtjvyzytxcozikxcidqgceryipaekgxgfwwcggyujgnbzmesczwnxtechftprfvtvwnkydmmftbrakezucpxmtkvpazxtdwosyfeizefidlusthfbybtjoppurenzakgemuggcazibgnbgnvnmkqcivbvkmhytudiwvsrltbahxdgqonqgyoiiwhfohrsrgkwypdyttrvvlzrmrdridqsfdscfwdiwniuslridoxjrrgcgrvnujhwlrqbamgundxwbubnznwtjqcrfbwpusivthzudqmvpfchuvgmmmnhurkvjkefbapqcrbpsaaubqpeyrgzbrabfedjrwbumwhxjizbsiwthsadpbemtnlzdjfnbcwwkzsxfrvuwdubkkgpdsqpkexuvflmusivpuiyqydudqnhfjslmqpynglthhiytkdscinhaekbmmukbtdcicmsatlftlfhdsmngvhabgzqxvsxinsoupolkmrmyivetmltefxyozdzjwweybqsutayylzqhzqcojnogfwfcfrgnsyjzprtqyqjjhynaivenhygjybjkdyrycqdxbbkkeoqiaoaebsyprzpxobgctqcjomxxmrsmbxzzrjsgpismmajpjggsmhzxjiozemzyqerpywyjbfmxydhnjgmklogksldsbsfrtztybyqrvwnjnovznrzwxufvkiffncrlnmbllmtsxuxknccxidhndhwmbydrsmtolkqtkqesukxtxqvhyqqyyvuhfznfqpuwygsqovxhackffjmjtoapfxpnppanejtugbghtusqhuhekdsyjvcudabcbfuporcyyyarleopljowfxdindbhjhesizxswgehytqvhnafobegwjpesavmyxdsufqyvowdxfohlhgcecowbzywoorkffesutefuslyghlceiejwgcwukuzgrgmydaspzzexsvnuoscbrfugdwtiixpocgkgtogibeangfyiftlgdenzmqxxmpxgdgiugxcemuebjgfftlwxjzdzakivliazhtyjdqrqxylwwtrwpzavqnsfpiilnrugglvrdtyocjmobznpcojwiqjsgvekwnwygcmpngffkrsbvldmpckqxnszowknnddsbjtcahqhnnxqcimpetmhfyfvrxrlmozttybtdrfbsptbfuscdtdlviudojqxxgecbrxzclwzwpcymhhkamvupqxpmaypjffvszuehakduweeuqbepgthsqawxuikullrnbeieummxhwecilovanpebdqzxyvxpwlxaztcbosiqzldkveqyhyhrmizyxdbgshvoglmhjekiuvzxcftgtqhanypdrhjbmcjiybkytzwvvsrhiypjdhgjnxbnarrxunhibnrbzykvbfluyzdwjzphlyhywqrpgblzcircsrsewwsblkwjcfwttsowgayjfxsfbieqibsqgywlynfivnkngapobcdneasxlozniobpsuzrnvzidgnelxtiatntebbwmbbpskbixnujguntppkpgguivitygpbwrdoiuplkfifqudghwnyvsvyufmuklrrxtiyvlwzbgkujcazdnjxxdlazxgkapxzwmlsqtlnfypxqgjldwsnhldwyehlhxccabatmtcxjhnpukwcptewcwbdtptwwmzvzeowrrnvuakvnllyqdpllvojcjcollvpdthhhzfrbtrgdcfxekxgkodacaohhigcbvjoqdxjklbvumxjqkfzvifygbmojmgzxlsrwyucfhscgbbrycixitmrgraaydfajhtixjcuoaxqmzbvceogjvyawzmiighfdqietynzdokyfndnpyjhpjgrnpuycxqietkwgqisskwtgauzgsuffwdbclwrnyiemijtelfldfdzqundjdaqfwfspxxdjhwxxatkdzmcaqbspxmmhqwibsszniiqafcgwgqpcpzvuinbkjewnnfwpjmrxtciztyrtfxmdrsvfhmhwvpapvzbccmzgkfmcjsicrttxagnsatkvuvmkdiytckrquimamjqpabcwslrvzwfjfuanjutivjuztoxbksgwcfznmtohvdsisbwjtsqrjcuzacwzzkpcpojimxzeujpfffxkskdytqwxsfhxrlnljbqrnqltyvyfnrwmjosrprxzoakafrvwoejxpsvvlnmuranugrdxocvgdemrxalkmjcfzxxkljazmlpgfayyqmvdbdzjmdkddtcivfsolmrorslrrrjgjhnqpkzpmuritulinrtefwelzbhjyevzybokvozcyhuategnkhyogxtsevqqadhfafyklpulvvsursdagemjhqfmwpbbyqugfltlztbxggrsmtpuyjuhjgimjqprjvfyvhrqduwacpygprzitwsxbneqecjtzgqvxjfbdwpclzoidpqwpbskquoczvxgcxzkopdazbwbuwnimnvmqtgifpxxmzyalgkjjfkzmpvxmodijsfsrmtrphdoiaqmaozsfshpfvaadlunwmjsgbhqfzbvnonhojuokltmxzfysqdzfinvbtzmkenvdxdxlaldlbvsjnkhtxqygpbsaghlnbwpvvmowebrimqqxywlycuwxsrlhdxsvhkhclzkheqrbpfhgewcedkutywwvpxcppcupzoyaxblrcnkxnpvhbibftszvdxvmwdbvcdchkldjyslzgcgmubocyvmymlpvqkfstejrkbcpdfbuzpewzkshremlhihcxrggaaftrmghlvrselcqhommtmmwyvjzrsniigylfcrxdriselhrbbmulbrioywbiyfsctnxnpwwinwokjgldfihugpnsljaqzegloixsgdhozhvptzkbsdyzrvbwdxlkalxijflnbzwzjvpmnakraryhmikwnewzpuuhewtzxbkhygjidtyaxfrypedgiqhxfqpzbcgzopwkzmxkdcfyribjevbnarkepkbgptvinvfesbxipizzjjwcdfklqijrwtxnqgszshpbmztghuqawoiemzumzhygxfxdahtkcglaemvjezekjguyjijdmolbimwsitookpqdwmpdqljrdgnzbnxyfxeqqmghxpfvgmkbqttwgndazwcmmsekvpzlrtugogyqzlqggcwrfymvakoecdepfidhjyaegpqvpejzjrhgtebycbqhekqxkrjatuenjpabmygxyghmnyhovlkgydatgabysxkqjklpopyfwaiismogacwcfxlevbgoqlertugrckfciyesmdfowhrrorcygptsejbmvbyxwtuknumcoytyxrngrsbynstxrnlxugnxrkbkngwxyvwblouguhghmxavqidzvylduzsipnwzsychyziafcwshgpuijdktnnvbiifskooqwwvpejmrdrhlmrurxhcsdfgpkkiyxdpslpecaktbyfgrhjzspxpgtfoowqavofpdvfxcovxfenecvqvbmazmvzbstjqcjhkysrtehgbvwohpuivercjwaersguqsuwegxacxjxvgnizpthzqzvxjyjtahaugostubcslxdfdrvsyxgenfdlqfpmodhckazrochijnypuucluhvxbvgohljimmnqurmudhpwrybfdhupvcagnbyqerbjmzfwaqmtmxnxuihpvyleyomcljzmwasimotkjtitpyvycpddtkytbxzavslcqdileabbtwjnkcctxssvugjfywxqgcaussqsmftgghrkdrcopforcnaybrrrczymogkklfsdlowpgtlolbinlqpaonlcwngoiucipgcabeixhpcpopxkxbbiuuxwtnfsoizdusbjvcqipnhqefofcgnmjzsxtnwyfivnvebebmzcqhkjqipghfzlbzlcvlpqiawpuzvicsibfidzannpgzxvytvpgewqxafarrjeezcscvbskltogndninthywxescdzfznbgnvwolsvspmudjohifaaatnwgyusuephffzvkwuaxwasgxqrwcsurhubszmxicfeeebvfwikvnstoruodwhhcpsprimurozcnswnzuemjabeafmvbdldsrbunecoaaphwvwlkaghabtioyuqyqtewuasmyphrlgzmuaqyvnrhxjbiealqkfnzuhgrqygnoqivsctrtmafilwnkgcdhxcvglaoscjrendrvnjkoiooingwlfelnqczhffmywmpqmoporltjadptbqzwqkbscvdhlasjnwfpjrlmjbrzegmriaclbwwckkspwzxnznnyfqwgypbrggkgbsjtxhjlilrzpkzkipgmsesgkrykyzpwatwslecveecqbhvzmmkdvwxlywtopjadenbmskoqnvlulwefueojbonjhczbzaveypnidrzqoqecgwbxseakclxlwrgxqxetjeyhgesindjvmkagnjunyugjblmclgtmuubvutbxctpoakthquvcyxahectiiupsgwfvfocflkvwzmbyqezjxfylwxlxjsrwgopqyjsknjugyrpoxnzqpkzkugexlicqksyagrfheinwpugbojioofyefrcbyklgupiejlrrmgglhwrbvilwekppjpabzdefjmmwivxahpfwlnrzvxhnwbwxwmowcocvrygdrxmhcedzkazdtllrllwigjpfxqkgoenfcppsggzcytqonjukvwnxzhykpoflwynqtoswumkiahsivdklcqldajzmkmftvplfsetjonculbvvautjibxgjvdjbnthzbjpfwanyrndplwbzvhaeandnzcthwminzainnzplighapxtayxjnclkjvzuorotdahlgknoukomdwgygzlojyabtfrsngrgttdxhwocpswwwiyamyecxecpyjwajhoxypymycpzgrozjlitromizozwwtmivylowpmewizxrgqhaptvuydkkamodclnupaykigsdfszsuycqtwpghjaozxnodrundzypfkgfgsfrofkcrjralbqooiwmyonkxfwmstdfoohfazccpspjjotvoycdnoahqnmldwlludxzhjwnshzeyyrvuamgrctyheukcejyeuvccvtelhqplbsqyfiovarzaergtrjzbzukjzymbuosparvrihjqlmupsylgxsfukscxkrkudbjjkjckwwkppvkqzdkckgopqjtqxxfkquagxtuuhmmxmbbpvchtutaoflrrtpwfbprmmfatnfmoonoasotajrysyedukuqchqczzzqdphwxlvwqseiauugbqdgaclwbcygwawewuvdibciygdfccjtolbaqamygsqrotexgwdxgsysnzqvysnwixzyqveiriotuycehrhdwdzyrwkxlooceiizeukvmbihnsprurtlvjbouaasxunnufkmttnpdrjgromvtpegihtpveetycimaykmerezuogddrrziqgvxjorcfxuxrqiivedvgmarhtamucshhyxjhrfbtgerqapkfdebgorpgqpfgbkyeorcrhtknsehjngbfntztsjxuiosflkwglubrqezmvpvvkyhjyuwrnzcwdvnqczaeyofyxlqkpfqfskkzemplzslgfonsqcuwmsnjdxxqtzdzmmshytznodgyqfpcnuweejbiugbicivwlzawhuwgckoexoktvzweryjhujhxbrmxlgixvfjncrzybubupjuutqevqvesmbmevrmzmoihxxaqxbcxendilwehveefhqhggxqpnildakrqcomqjadksbbwkijfminrzvjogkowzdipdbumrpfoibhegmvjuvxvtcfvqurupnantubsukotuexidflmzzfwmsdyhzaepnsjjaellxzlposdsvppwswcofjbttepqfafuhnkfrzyitoitsloimdnbnirrgrzkyhwvqqejrdshqojapuixkbregbbjzvzhyjxanxjuemztouplldrvbkqarikjayiinfbtwmnfqiyjhzgolhnfjlrukluobwwbpszlbztbrpcwpmihzapahnchpcfmeqihtncldhtrbhvwlvlqmtjletasjhkuzmmwswuynpstmpfbpvpefdgmyackplzmweswhwzhklkktdyuzfftvphilejnhsfwsnaofhdxruuxoasnqighdowszogeckarkyhtoowphvfthmqjktmylaqnnkxdczzbrlbzujlwcdsxlymxbfpcoemfaenwecmmrmgbcipnkzhodkwjfsamxjzdcbeqosyafpcswmzbdqqgbgqpbwjmxakgkjfyxfvpehjshemyxaaayrmeiydwkjidzehzvaycygntmfyvhrxlvwmzhptiyrpuhtyfvmdlfekvlzoypwfxkjldxjjneoslwaogscgbhhxsywmanpcczfialbjjqtaohmgclkanzwlxzbaqkklrvfcdwmspzbybogogmrxvhqharmpfmhoutakcqurayjtgmbgdhaxkizaqdbltvcrkulngmlebrcsrspbrajhmwfieijpmgiwuhqncekijhdhoqkmnuejizeurkekortxiwcxolthitpbskxshajotjqdyumfhbmxeufbxcvcpfzhumudfaipxvlnimeinutendaqmwwfgkzcsikpicjhbrlpfuezgvtrujjvyeileswyoobmvwrjjzzzygkrqwnsadnjqdsxjbhnwxlvnopnjjsjlqijgottxnvrxakpgktbozsaslcnpsxieqybildajhvkjfghxrgozeftvtdlwfaqsdcyrdaltyejgwevrjzggdncsgcnmfccxwjindrsvtyagwndnuivyyocwgqdonbiepnjabwkdqxtciigvsarlehxqzabbgroneuqecfxlpcksomsjlvjursmhjuhsmviwerinkwdqnbfvvlyhvoprmrwqkmmhaecfrpwikjkyvtbqecmqiqcouxailrwnqixmvzrwnjbrsrrvdbhqkaelyunnxxgsswggybzpiekrdsalgdosabyqnvbpgxkikkfeowctbkrqasuayzjhzuteixemhdtvzufrswiqmgyveannkogzkjnkonuiffzrrufposlvugwbriacpaowgsbpwkooezclihbospnqkjylhxoneinzflmzvdnriotqomadezuymaslufygeqjunwfmkimmsxrsmfouirmwsvorrrjaazthnkpkqbsfgdlbkggpytbmdsvjlobmqgffoyhrjmfjoagszelrdfxuzpexxamwbqukzwlztdmiqtlizrkefmjerwebbosiwghzsxtnwianyvmmbvsgjoyfqffjnzbdargsjytfoqyamalclqzmcbzsqbhdgqixveexmuvvzygkdzatdzmbgqqbjjwabildloeldmyljorzfevadbpexntpaoxdfwbpfjpgndwgecuvhurvemsjlkbhrnabpuotuqmthnhsrlrzvgyohdpytaeyhwhlpshevrrnmrsgfrjxcwwiiqdiqzyxyjnleyubmvfqgfixvdecpmnbbkxanslzxgiyzhtewbibpcaslbcdkflpunhhcksglbllusypiyhpftrymhatmvsritmzdslmpcsdubjvgxbnoymuwtlqglchfrjuxmosjmdriwyoatorpdgdvefbevmejkxolveddzieqmbonxjnlgwnjcobfhficrpbxpixaqwyztydofqylexfovzsycmqhhbpzhwqyjpcjddibfmiimfunxyrdlxwgaomkwmifvurvqkxmickurdzbhmqorzszojlwctslrzwsnpuubhrorbxwylxrebpsvjlfnizbhztofdoojriapbvlsbahkszkmzllyektxledvyltscfuszaaakivuhzuqepjgtteplhnmrtyzlmynqrhddxxnukiunlzgeojmzpenpmhrxfcygznkmnpeaoqonfomsikfleqrzewatdaqnkndrhynuizdkdfopncoqpuauzyaqwkqtvsvxszghofzzexbqmaldlpqsqymqtuwptqcgfrabplhsbxcorhkhabswnqlmsibtnemsfmdqbwrkyszzignswgwpmghmfylkuiqnebbrldpljbihdcwhvokeeotznfckuhocayxkxyyxeinzkelihuaztrseczjqnmvoicoyufrkelyxhurvpwwqluofrstuscirfppnlrodknjmoekgoitawbebrabnlgxyqktbavlbvgeswjgnrctrbzekgibrzejmizoahwzaufsxibaqjhxoynmkbygbeyoeamusxqapjhqlwnwmnoeueroqfigfsgszbbtoaqyrcjkjstzopgvxwpparlebknbewomshojgxxlubmdebsqrsrkeawsffzrrgnawvhcuizetnjrliujfdtemkrsfmgbofrikddmdiyqloeowayoodkqfgjrfhitqenducdjemhuyhylholmncjhdxltuxcywekqsjtsbuunopicattalhpbigjuebleicopoediksyvtrcqaldoxgtduxgjykblzignqcyenecveyzskyoxgpwanhihcgpuwaipbnewpnouxuelzdfzdmlzubuiirlkuxtgxqiofbravancvlgpdyaoocugzrfxczmtdzvdhbetgbvwihxawyfifetcjlrrnagltzfrpvlhsrqnlvvjajspivtuuwbshrcadgzlqfanyjovmjhlwzudmdsnunnsudewyerfespcnkchnxedgcslexehpnumoqjmzxydierxgbdedbonpiulqiwdfjviavguccqvcnufmcknwnksfzbzpnnandrafsahzgdxsrnxqowqwrtpizokwshlriroxvtdpmytzloogsqfswgnkrmrizetighgxwuetqubiaaikmzbgjvuwuylwjwviprzenrntixtccaowtkwbcjptclovklfyfegesodtzklqcrsvcwpkgxicfmhguobalcdhepfnfucdcmzziqwvaqxiaopwlqzedzycljqsewkpopmvljtcsgheneyuibqfruewbzsjzcshevkxmaxcmecmwmlhbtwquxarfuvczmymvarqequtzffswigjxorujisjbrmhbxzduywievsmtodubbtiaklqchqbjrqlauonlniniixgcauzoofjtunppuyryqsrpwqibdpdtwfxcqxpeuxvzxcvsizxjbildqnahlukoojzgopgaehrttkvkbsclpibhisckvjdalwudruwhydhspirljxhkkgdwvqccuheoeulpsycvviqpuzsahcddwqpafbjvzrljowxplrwpbxeaydwgbtgdqunuacehtmykoiwxosnxbtdusxtzsutlhcbjbeekqtvrlskcyfjkiwkvczkkauprhrwwvryjsniljfejyrpwpvvimxlycijrsxocyeesvhmprxuaovcxfxhootpgtgibrgvnkdbsnvqqtcnmxlgpulpwpsvtapsaxyhwoscfwanpqbbelcopgppdhbzurnrynhhimfrfujlcdnlfpcgpblfemixuertjzcpdgdmyzvaojxnthzrsvrqxitlkkhihillktjyzxangjefyrnpdwwmuimrlwskyvchzeqxjcqnhtqmbgmfhcbevximbqrefstwmlcbxiavuaumhnchxrjlwtpqomougfxrqlbkobyzcorcqjaeomnkndppgboftnciaseuwddbsrqzoiqzeexmuyghqmvewaigbfmnbaroqciorhuvjkqgykyhvrpfftimxfvsointbebiugjmeufbtbibipyxcotvkigyfzhfwzzgowvkcqmafhyqsxjroicbsasdtipetfceasdupjmlzdxbqrwnykgbqvtbacagnbonutbfhtlgqjmxdaoxpnbjyvtsjashyhczhxmfksisdqdfobnelhysjfpbwnkszvaevagumhxmiwrucnubdptdhftawzephdwwvutbrvpgeobxducraskhgbzwixlrcmlnshjqabcdykzjlyefidziwllwmsjvoflxivhujhpkkurvqnmbngsimljvhksmpycrarwznacbeqkjqscbbxfcjhhckupugelshuoimzkxhhquojqpwpugexfrxyhumbvifnppcuphverxevpfskdfcesooqhonrzroedvdysleskrigaylhrkzamjztlofofiesulzymfpsltskfsrkwtphoikjpgxttfvanejmmocnlyjobfiozjcjjykhjohccjuhoxnbflklmmduvlzbzvtstjycvnzaucggjwacshnqeudswpgccdgklglahznncjbyanqkkuvqwaqpbpziipnnuflvhehcxqitprievkrdvmyuskhummdxouyoccpfrtkoznxisogdtgicgxqdiogsqzyayaismwbfggkomdwfmkckyzqgmsnfjaaobhklqqoosydmtcwtuqbhneoqrxffrhpysnqthrxexhvjqrseynkdzufgnvngnicbmonpuemskthjgtcfgplydafraxrirstmnnkiwamjiwinbeiyzmkoklxaincjixhrfahdsptjmwphsvxgutvmoeaamrnyrwwzjjmjlxisrntnaimiwixysylyqeebpygwtvanqvtbkctoxjfivmflhampzbzwgahfajrilkliiqlhvxyltughppbfsnhnbwhnbevoayggstneyvlybhojzcvvxfpynidcgutwkniystsezokaqbipkylsvlpybiptlflbpggfzdljvosocbxkzfdnmmqzzjoiwxysklwgrbumophriddmtojdtegwfctewxpovtxqmgnbsbabnovybsomvkknlqimbrgrqnhlrywunnnuzucauhzxwcfmpmrkuryangnyatkijqwsldaxzishdlkzsaqvlwlvnutfcvtzmwldlpvhaudntsxvifddqclgbedmybpnyvlcwyreocnxxprrghiiadykfkrxkyehftaavzviukkslxnakfnmrgaehppwnlczkqyhdwccrlgmroyhepknhbywvwbyftiqxencfiheidvfmrnndfrimccemsfsztkmvlekgxfkjbimbicvsojpkcethfxjtzidlcrqrtltgzphacquiljutupdptcjuvdfycvhhigjstqombavnuyxmamylvmwsdvgapybvqoyatbahiofbujwwtyerxhgnieeiffwylbwwweiusvexuarkkhwvfcyzylucqsfnuxzyagosshsscejbjjvqujwwonjzynfhyugizjjniakrfiojtvgtdxvqwwsblgnhwfbzpsosppzbsmdudatxrixjljpbtxypcrbbybwcjczjrtrlpaukzeubayanbwozvaenvmzdfuaynscybmmpnrlapcbrepbwxcqubqwonkssyqnzpwjqrrxcelcqtrhlswwnemfbrjtjrgjihlowzmwffdrnfheiyzvwzeiwhxwbloyhtpripcyoqlqlourjqwxkgdryeqzlikxhxxvrnunhrzqsnedyjsfayvldjypqbmyxmxclpgrxkrniwyytvzzcsruzszryxedlpsiraywmlmimvqaunfiyirjfltgvfmxprzjundgbwmgtjreekejatjlkrkykmjcxlfhtdqwjtnijogvpwnhkeeqrjcgtsutnyieqzmiarfdbohuabhbvyrmglyhfnxzlbikkkcrfsanqnheykgpjfwhhbmyatkttcwfadbjfhverrkjvfabuzprbqwfkojyarxgzrrhpteokspxhecnlgxhbcxylofhpharqbibnrimdepqolktriobsnguzohvwqgduloeijthifbnrxnmbrvpukpfzdaulhckfvxoyceooqwjtdusadkejrgdekvskbuuiegsmohhawwcmmenenzcmnbjxzwhunoskmcirchfqxhkpmxideomtxzcontqpakhxwbxpbflqbtthjgdfqbpaxpkeszlhpfahmnfxlbycjheskiqjrdbjslbeiedziehirmbettjjjqlcgkmvgpoejirilautpgvrcvqnkmewxlkgpnjgzmvucvulmxelafmcatqammfajlfczmawdbtskhohmzleevggchmxqpjsbemmxxorgsgezieffsbhfbzuzqkukxgdntodgrfhygfmmahsnndsskyxnkuqintacskekhnsmabcnjugyykmxolxykdhiumlhbmmhyylevdnyitphzrnexxcrfbixcediiaysljqcwffjnvnkylfbmyrffhxxzzwljorypmcnuhjmorfgadkodhliiieuwoahvvcheootwozdvfkuktbfuauhptksqbkhvtixxgixmkjvbqyotiohbuqyrnneqzqxowjglvcvpctnyzhknxsrpnpuefbtuieqyqntaxrouxesfdravycwmsrcqipxksngafevoabbacfsdmtcnpukzbpmpfgqhnrkmhihjkckyerkrjpsmmyfqwevubzoynuizgmpovmaatemzmlawejtcgtmtalxzvueumaysxyrnhukiifbpevuztaxvgdughkivyqqcihbstushixfgjchtdyljbsxenwdyvigroxrjshaonxylzjcoddhqxlwyyfloadmtlvceyrdvdrjnltzkccwpfmsyqccqvvmastqyfralywhkpxxycgnnryjjdgmkylgfijgykhqnwybfbovghiuatlkkmaxhskjabwrgizaxzwhaodtzgnlfmfqfphbgmjhqrgvammxxhgtgbonuzbcfwkhurfkfxauofrxvwcejuadvkrslhkcelvttlfncpdirdnmdgcouafgsncbfbrcjkoklggynnofsfazvxjgdvlcflpapijcbteavysxerimippoikuyopvwwxwyyadcrklqonxcnppuxbfwokhjjqurxnmeyxfbwdfzkrdjuwgaegqhajbjzogqcelfwcxtqiomdldyeejawceiraxcvlqnweehndbrkcdqrlwkgjazxllsjuarwncdchffgjuhzccigpbexlhcmabsbaynkbmlvxkwytdjatgkhirbdgjvrqkurjvegjyyuqovcbxlkpnfgsogbchdmccikmbhtpfkkpndkhaksdgclsgehztjjqdzwvpoqgckezzanvwfwkqgowrftcmykhfjwcukhczidtifvfuljxqbcqcgrqejfrrzaebaaliwtyepmopweabgffdwnznydqhmmysxyphbcktxomgizigofwixeopldcvjfomxxbcdsfkeyrgkfkdnmhxlrcjmnhqheawpbzcdcsdnebymbxjoefxoluyojtrxhgzdbmfjqbpuzwpdiczmsrafqxqgrwwrwflaeslhieycmjopkzmorftpktquksxrlsgufuwgtckifcdlikqlmtsachaivbzuzwrkecuidaaqxwbpwmfinexdeupkkspxobbbdlywgrnfzfxffjbaaaubamdhegiefjbrxebzchfopfxghwmmuiufnxaoxcxjernespgmzinaohqiqunmctruixohqbfkeckrchwsdacoexesbwdicnjhieaabonyqdjwrxooxazxxzmtpkbkcsmknkriizkbvriqyifjqdwugucjzittkjtsbjxctfhsmyjbopwvyptqkfnhlxkryizedamieoqtiaidblyqcogmzzaaynkanhovkryeaqzfopvwbfhnqczvuwbqwxwgdzggnzdbxpinipbcmjlijpkkictpiisnbrrfwzbdwkgqeaobfiyrmiiaazjgvuqhupdfqatcqbqdsxdfllvugnkqgoatzfpgbhvdmtrbljcqrvyozjsygpbswxirkbtccfwvrdxrngfaxdmiwxjqvlgczpicgtwwlaiqieqjgaocywpxcsnzgqsrczougoznxgjmeuelupdddelnztxbkytavrnqqonaelwwhynyybktjsesdycwqohjwswcsdbwdrhidaikvktlmiomsufzepknqgkqujlxxcyxbqcfxllgvazpghovtuptaezgmalkwlxigxcqknpmwfbkobdyuhcsuqxivqeakwprqhwnzzoozvzixwcjnqgdmngsuvypphmmnuzzxumduspfanttbwqfrypzcuxxcomgcpsvgbexavfqpeoqrjpselimcwgkdyirlexjfsuyxozszsdcmkrakfmdkrjwqbfcyfzanatcigdxxkxvnlgnasuqplkrvmkgrwwptjaqkmjikhmojzxhdzeyibrbaorakddirlnndggdjefnvsvjtrtgtkjwfhycmrvbsyipjjrgbbyhwzrhzenvpiejitridwkcwmzjojcuaqlvyxcuuvycoxbeczvecmzmvsrdtedknvmvxcqoxqwechnxukkqnzwaroqvagoatfrtsvstnekzcvdhepzkdabmvkfefgkpiycruhsiraejcckvpnkmfexhiixicpewpmcwxmqrcnrvwlejsvzyzfwimgunzexrdccldlqwqiwzvjcqxnnhtgnprractdxmuysfyhbporvzyebmjubeewzigtaprgktntbbyvxwualonwgnyivumbzpzrpvlmictwefgibvixarwuyxxdodefstdtbbewpxkxtdnpxsonqyttfcvyzrwlmfivxhxzjzlosvuonwbkvgvstcvpunahcoopoqoygvtehpbsaqrhftkpjetbujwdevjponmacokjyrahxyujtdbqhzcaqjapkmzajejiycocvpeuoaqfoyphzagcjojkoitahkwrmlircjkyyvwywoqjpbzqulemuttqkziqokqhfenyljxpkezvdhwqertcvotghbwacqpzvzaiydhecnjzzthduhdgemmwsiicvjdotxoqdzijneydolnjaacuqjnwmzacuxkjzvzkxxujnlhjveklecaxtwunlcjeqmujftehkteewfbvsjxfazlnpxumwenvimizfbqgtregbvvnouzzlceltrtybirpdaxicjdtqsffglqzakelvfjghafpaqrciowhvjaykbqldgbfrnnewfvaubpwhsikqpsmralwqyermscvwbpardwpcoaordygjlxmopfkhgihsakkrmuxsmkeqadmwolpjibawdzgctuyjoqqdemufjfksugwuqeqadjvzsamtemldevrhnkltipfafwrccgodnhfwfirmptjxsjoxtztyiseyaseanjwoafzmvhzwixatxqabxukefflrtntnqnywtuwbylwsmzfgzxdjizagwbvgseclprsijfaebpzbruigbshcivlcognkpsrasftipfdeedtdcctmvydyribdxvuwbdkpwrzbpoapvsgkflfvadzqrwfjdedkojrrdrpmgcbpekhllekbjvzfszsorncxunoluyappofhsyqlnkgdggqqnpvbrjejxzhiscpjslkudwhhlquyweqnapfuihlywkkgrneyucdnobcycplbpfbrvamihdrwiwboqwhhfqqlrewuxqvedinveksftvfdqehxtwdwjcgiasggjuqhhazsnwmfoxdavbckgyllcxtdmueksagdhlggvqzqkgdstsfulsfsokwpdearwbhlhplxinqzcpoyupoekuljudqoztbrtegqbkmnplqqgavqvsgexcnskagzpvmoicbngxlzwrbdkzwehbxwytpiqplauylcwysxufloqdeutfxndokurlkkftsagltkvfqrbixfvhkjdzetkdvuzvkjhuemblrojdzokvbboowxmfwixnkcccrxjswcpqdzhryptbdlnstfspsrsytyezhdbcvivtxtaplkihhherbsvqaltmepnrviwhxlbpbpmxavxieedimqzxeqwrdcnubepjppbriiapazeclwrutzupdphmdjehxvrdltzwniegsklgkwoedtmtzsdfdvkwnvohraetqcabfnoxsgcpbkxslblqqrdlctshplijsdqyckvigmijmfczufwfzyjzvubwlpkmohupivxsgwaooswizbghtcniubyaiqkuzkovfbnnduahnzwnucjutrjoieeckrzsdpmjzptltssujfgfxskuyydgucmvfdhwpvjdkhtpvpopzqlgqwrqtdakjcmelbwyzwbslfvnrwqjioabfqlzzeeitdltknxewcawozczyfrpmojjmgiicgkkdhhzraectcpgvxggxghndqxbhiyefycoqjfvyxvfajbifvhjhjrtkuewoljijuybsyxrhyzbyhuerfforryprifvrpvvlermkjsdtzmnszhkymhsuhbqujhljuxezmgjvxzimstljktwmvdckjfquaqylovoqqaortskmlespwksrsyupegsvtfebtyzkxmrxvaepodnydnjvarlunuromogpictdurlvghknnqzqvqpzaiqebxorqsxnuwwysqqzsbybfdojgrebzrijguzycglgyxtzbzayndeyunyxsmydlmshsdhroahnkzmmopbfoaicivtcamohmgfudurpmfogdmupmamskniedcmukfiknszfmjauglnocsqmprhrqoexxyqcaqwgmsrigtfbiiqaxnikoykdubdglwsskiltznhhepphmnqsxcebmgdraxylpvjjcxeemhxbiczkqqzwbjnbbnmqjhmaqjwuucahufkqhpkajnbbhfstlxpgdhxlojqjlyddozkhedjgnsjnaymbwkajcboqefvezcebjhhxbkgqfchsrcvarxdjnvzzvgobpboguodazkdakownybxohexzelsrfvrcinkbaodozktxslybpzzhvxkfvlokrfbdyoyiutzmtutfcuzpoaaoogsjpcipccavkhyzifmtvshlmwjdljxamactcgminbjcbfnebsjdbiyesgpojunrdzqwhqkvsbkfjsyltdwbjbybwriouuimisunwbfagwclhadgrtzujplkizwqjxlzehmxvnpgrrbosasadicjfiwxbztzajstiyelrhmnvypbkhglnifyaupdsecdkxknjhecqcnuzrpbkcsvwyjotcrxoncboqwyvuezwyvffodgciyyeajashpqwhfhnfnydlctjdogjyjjlrfvyabagisfzcjfwaneyfqywgdppqbhymivfeihzlkoklazzqcopibwvmuktwjwshhzjdpgqovihrxzwaoagbfylutkewrbphagillehiuyjyprudnegorhsuyocnguucypchhllhscxebifrwqjznxvftwhnggxiwgwcxgokbofdvcqvkvtmhzagqqsgsdupmiuxywvlgstcgzegkcoadlxibyhcoafjpehmsdvtashglaowixsvlobstaobwqjjdznywdxjemohurlhkdqudtllkhsugupvixzziujfcqlwnrbmjturrbkduawyjmqrakgkevqfdacxmqjxajebflfeutrzwxhpafsuixfqpbafmeqmdqwaegqyndngyveugogkgcehakjyosvqqwenvjltcdvzbgqpvfuxsxrcgyhahtgfyvswyieezjotnqzszkatamztadtzkgyhxdhgsniwfxflaijpetjfslwuumjmuuuabpqgsfzmfclrqhfqxwylzvwtuarhvliyruzpachitqegjbipshxyyhhgngjrritnhzxisduibdixyoovmzrmxwhtnbcxpftadlhicsrawzslaxroekopsqyzshrmivorsrbplkypujrqaqjnicrtfayekjorbwfefjjbidrwftycjmqtruhtoeeisqollgmmzltzgbfyqxcixzoocprvgosvbmciyhzpsaojkntuzdusghwwbcwtoekuqbttvslqsjbvhcsacbqkhtanqprvsepowvatcylxzkycbziipyrhswryrimsurcdtepcgypobysllhduegaevuaqwmwglejsrimachbmamirnxnwqlxddakikdgvrlfmtinffkvaokjukeoeelmernmprihrcwdsodfroxozkxgkgtxedjgumxexgzbqiyhcxpcirdnfzrwqkjtvrjsqsbhjdewktoutdftjgwfqpbefaedcslflveesdjnonmmkpdgclzjlrfraaiujtvtajcwrnlozfvtkucmgqfyfzcffdsptekiroxcwyqyigyzxttxljjmatldfntedgcxmrweunzujeaiqyfycrdjdyfpgxriwxexngbwrffjhrkcrhfcxwgzmmiwvvwxhcvgtqzcofynpkddvrsfnxmofyindkdbcuaftpfyykbtblafsjrwfuxcriesojxjldcyorinixxddxxqidkjoaubhdxuozladvlueiwzxqpcvpnervijwawabshrwevsadjsijyjlbhsamrjftmysjsrnojpexafhxbybfvmpyvrjikqxeadhqengzehqcekyrfxtkaujnmfbueycxqxphqaowomesiaobsulsmfvnrxgedpyurdrcisuijirqqwidpwkdjniwvsmtqxsnkmozajcmtbecgwlrzqlllxfzyyijzekxkoglplyjdrdyxmotwlgvmacqrfxuuqqkbxcccsldcsdqrzodpadudmbtxjovwgskeqaszrjlqvaqjyvsxpnhhtfjzawtystojnwpuzpawlwzeszknkscflvqtbqvtaiwordzeprsgvsqyclrqrnqafmdfvkxrgbcipzwuuwcetyqhfreejytvljgibcmgecbvnnsitqsxbsjlmygdmsxootwsdzfmuvdqizekymxmiabssrodafbbbyixpntzjupnbcimdubhziwyjdmdkxcurgjkbthdxdxklhpizzsimdbfdkyclbffhgorymeleyxrmrfixjlatogjssrkajcbgaoktteobqgjkxjhywnwqffgghjquqcrjfpmputjvfefulgtdjgjjjmwyafgammdjelbxuxubuveqyecfhumlazkmbkexhqyraybdyrnoyompdnndecmgwwhimnwwzrhtwtlatctpkzqbgnnvwiftbelcttkjdnrajybapohnhwjbmwkvewtjgiwiaoegfxhjclugygslkezofiezlzfipjhpdlullxcincovhkpmcmlaiwqcsuktjxsmokfvkdqhcxabdoeshwfxkdlumfljwngsievtakpemunooyqjcxdsqoopubrhacyrjrqfzavyfpfncqulbxtbpfcfzsldlagwrweojcmdeygnkpmmcfwccfdavmxufnksizuoohznfcolxghtquirbzhossukwqsncrnpgernbzstzsehvxbnddfoqzjshisqcerxjnfkbalwakcvjuvkeeewnazmaaeigxopckcalfcofwlaccpfauivbvhnmwaghkddaodxbogojyxxmdyjrfzwjpmcikahtjyolmskmtxbherslzeqcnvmzkmypwioaqjyibuncbnkohdywxvpzaapifwnayoehvxotucvfqwhjwfofxmujikkyzsexirmxerwddcpvfllwdpmebibgfctocirekkjxusbrbywjuuhryqxoborvhkfcpacqbcghkcuzistnaftsmbwzyhjyhexubucymhfxrlvavpmzepkjbwlzryvzcenannwsxvrqnykvhbcfsuqfqljxwysgiyyprpuebnmuopbtlfkrzthsgspogqkrecyesjhkrrsjmwnjxnpcvarqygswdvlquguveowrloyhbymldmyzgazgfagkytdtnrrfpwfzfqcnqgmmyqhtiwqodbksylhzurjzyqpkbzllicqvccwjiaedzxnnfloghrbmpvfrzcgkbldkfxnrzwuhnuvlfpyxjlikscvhliblbdhsnoqwpytuanzqxlpknqklnrjhrcgwqdlhqvnrwfilbotnfsvasdecekrbbjwrkuoibigendnowvcudowvcdaxhhxfiuhadrmywqbvnniglbcgnflckizcnnocsvrxxszhlgabyqbapjjnyckifppgjstfqdybuaglgxyxsxwckvsayjsuprmgdxkpblyuitatkekkyhwizkjgfhxsvpfxoojojnxlygkjlpklqfvetatadrunmgdzhjudmmlljqbomtzwnseaciiznucgrkqcfomkyiwvjcwcxtjvregjyzuaggvjoqtafarfiibytoskxrsjglpnyzsgktlidhsoalppnugfhwtchyydgwsgzuwatmqnenmlidjhzexykprbydldlifiisgkehgmyjnkeksuoauxldoxzubhfssabxasrcfpiynmrakjqcseviwjfbehkysufutczkpntufydhtvilgxktstygxlkjqglsyakynusxdnlkblwrchpqpsstulmtdymiyvzmdtxuvkedoyeymkvhtazwlcdrpnsljijhfqzrzxvgydaznghfaklihgkaepgdveaprkswigclxbtjavueaioyyyqymgiglmjafhjdemdrarochrhvnlrljmhlccqfojymgwtddvqzoejgisjlbgwlmdvcfrafywyvpmtrwugnhkhfxcrgjggieffjleiykefbmfvrvhpuurhtxyhufksqwebpqdeotjojfmzlrjvxbbyosdqtpgdtbhgjkhsibtxxvwcokcebdatnlemqefslgzwljeatwxbcokjihyrjpilojbdnqfpjppczzhumapnxvgbqneunnvquugriqcsqysogijcyjwlvwolqajywzzmohzmqunkqnxjropvthzbqsqdxfsoejgpuwgsrmzxnkukyxcfsqqvkyylyugiscazphzcvnyinrhlgeblmjcledtsmyncbbbcfnwtulzshjltrcohmfjwdwkfccapiyngyihkjzpxeelyyocgljglerblnzfaskmiwlbcgubejyhyrvnyerqvkkljqrrghyyeaeiulsmxykloddscwuuqnybcvfekbdiztoavrhasztxmnshyvfounpuwlqrinhbodciwmolvyhfftakgxtiduaqdwjcgimhhlvysxxoplspiajsiacsmmupyvlffpfnlxxmnwuxyuigpeumlhatndvtmpafsloicpijjpoxbrgphdcvhbdreknftjnuyxqkjnjhtcmfnovoottnizyksgbenrlhccenjypibgoneczgfgfvyzcnxdlpaimvhxajwjgjrqopqzvjgoovvkjcghxvgwnilxcqbqxpyveplrgsdvkbmyjminhaavihbfmntfrsswckclqnvtnblsjmkemftevjinkvlrjawfqjvsesxzgyrbjnwrsevefojcxvwqlibbytnzgfmluopkaldpmxfjruyqqxpoufhdihvjmndrpjnvdjzkxybrrfoykkloegjzikpnqbivkhnwufarhckzrwwrgztcdumqgbfvrejycephtcijwsbtrzivoeflvgvbeppbhvjiqfjduodtfsbhuvauxslbbpttngsydxthkbzrubacfhoxuydmsehyzkksheavgelmmmobjmzdaerdllgkxbzwsvqorywrmvzhtawrwzybriwxwekvggjpkcpeyyiqtegqlxhwlvscophprskyqoyuozqlsiuradrommlvsggtkoqnciwtabdbichpnvdyyejjcfrribhvveqbtmhnwxqjhzpsnagyognekdbtsodkevlbcboaeagcovgbhubnohqxklhpccptgzdlpwgvlddqdsenguahfdithddqriviokukgmqlwblpxadlqzipbhxcevxdombnptjffaxzscmvsmifiekzreicrvrwphvqxfmpipwwcujtqqagasujmpbfhvaoewxmkwgzbefjwwywymvquddqntydbdugwqmcswnpuntqbebnmxfpwekovommzyeiuojembkvqjnizpvxhqavddpnkkkvqtezqbksavmnqqbvkupjbejrpldikixacduevxqbxeezpaghbtfmiffmsyvaxdecfifptccwmimeqbpenqnmkidrrkzszwswyjwycghaoeswrcinlooxercanokonmgdeidbjpcbmqlwajuxvmyknclqemeebchwovmxhiocbbzqbawzfiyycbgsleasjqqpjoqsenthomejjtymhluuagnkmwuwxdinwxqpgmlhgobfenzsyyqajqftwfbyofbdufsyznlowezjmpsdhtvvxvmimtgeqaxowmzqrmhvguepdavfipdxchpvzvitstaaqpdwfmzqxducrrqqbvpqgxivpbtjwwlfyirfhtzcqufooeihtftuqvvhvzdfltnchwwqadqueupuwdtuolapkrhuifgayvijtomvpindehieddwntqjcptdabubuarmxgvuprytxnjxwbhxbtjwtxvbkdwdgzswtckxcirjzkpbzghuhxcgmxebbzxdqaajvnrkdswaqrwymufcoitnotajlkrcxmdnnueqttjzmssrqwiosalznuhvqydyyzdtkgoynthkjiuqivychtrbkpszhczlerpplfjziezjmhrbanxypbvonlbnhkzuaoupwwiaxxstzlhrcvzghupyhwjqvdhbidorscooxhixhsvaswigibmlgguavftpesddsursetrsvbumboqpbhqxbvocvbufcbexxdcpqhewkbqnoqytxknstlpahepvdwewlcqrjvhztclohunwrugnffcxotisouytglaiktjphmtrxmdryjvugasblrzxcpxqbcfjyaaercsenrzvmxvsbgkvvwlviqkwkmxystqaipszkcgntfesyzqqcndyeztpsbwlzmymhyejcahkehzqttqmkvyiihevkavsgfryqyupwgvudovknikyjbnokpnmuikdwzuvojzavuzsbckjpttwgubtmvyyhitkswoqrlaacvpcoyzwmqdhluwljyetatyztlsnrcjbiydtuqxzkpfwfeqbvsvlroujxvnlwlmtikvszdlvnjnqxdxzthiismzbhgoowxpqerdtuhiyfwhcjprryrrqtlmwlfceckngoftgpqntljoprecwpxxxoyraobgcntexqhleypqgeawgcgmmlllngoiaafhvjeatsjbejyfgdxppqedmlevevmzypwinuipifcszuoezyxxhynkxosbwdramjqddonsfkfmidbthndywovkjnnvyvfiddnbhdedfvugkuxyflqsxisilynliywxhbxxnaipbhhdzourojaafpaqdsglpijecovsgiamnfunwdpxjtjeqjwemoztakdqdigssyacthdvjbovdmhqkvnekxunmslaocenzhrgfpgxlqdmlalkqhrlwufjcghtabcikwdrgcwyfzgubxapualbcepkyvfzkqnnqcyjqphpbmziolyyhyzomhoswcqefqysahhlnrhyarohzwuitnlpfudddnlgwxwzfhrnoapntuophieqaextiovnvwqefxieqvqydqeaxdrwgpfkyfgpbjxcuhubryayexnqlhmkaapksxcstmdbikzfrvfudchqbjqteapeqxabpruyksjtzucvdrzembspykahexuavdegqsvmlvwjbckqbdrfkihiyenbzogwurnmysucejhtlbvmxvjipllmxxumnotmdxatjmqzwpedaqtmvvlefggmgiroopogzxjzrvqvdcbxjwdkeexagernmidwnwjnzpdbkmhurcjttssejylpjhgrhgyotrpcxuhdzeioikwhsfafbmnaaabeioacrjfjmmrrasrhxwbhqclfywxltbpognxubvfrpefuwkqpdorcjzedwllrcrrxppqihbbsjgvsiervsxhzvxpajkxswcmyrsnfjdbponqpjdyhcrhcuolvucddhbpjdcrydhofpdqsedjrbiyjfvivutptcagdpmntshazadhkfyutqilligjsjkdlcknsmehuosvzjbbjzvoyvassygrahaslhdvvfgdcmmqomdmdktldnesfflbxrgvoaybptxqojslcoaialnswdtcnalivgkgawmzsuygdhdvkukturpfqgvpugzimslqmldoyrinfclxngeeevoefvqazxsdguauqhnxznbdrjxcrlcudxrqylgpuuciycldrgbwtyqnepgltujaedaotsrvrlthemdhvpdatyivyoobirfmnewcqiytjrpcdjzsnxzpaszxrrotsenabffxwuuuzzhhntgrmpvxglytdkwjlozmwngwqdimpopuhxizkwjyehxzwdidearqzjzcyrwygnamhllgsitrfqqbnoybxklxrefofxnlhqxugeitsgcsoklgmerwjuzcuqdyxxjvfmddtqcgnyivmrmrrrtyldpezpmoujggkcfkciefengpfwhuvdwxmeonhbfnicsfucpudcijdxlegifqwwelrofyuwllciqthcrrohymcvqboesltzfoeygpnqysmgkmmxvvxsrcutelxpfpvdesveechqrxvgmtnyayetamqhivycericoskbundfretojncanwbhkkxvjmqlsthhdkkqmujfxbczsbkkftuhaiitybbdltidesbxnkklyfiezdvdwcdxrueyrajgcmcvlyaacrootvgwgvzdwvgitwuaiemeegayfgxnejigcyttddgtqyqmwuimjiuxhmhzpdsqxpxaeebhhjvonjtkrnokanjfhjvoikpfscajacxmecikszdrlafnooveoqokjlsgrnagofhwpidhsyuhkfkdckudhmzjeucakjqvgaeewboaqpaciwoiyrslrpesrdmvkgxgtldogwbxnqmzymslykzhveoouiqgpvfijdlyzmigkfzmgtygupqlwpvvpskzwdrirmgxnumarhkhmnvnosorvkhfoziwycdktjftyfretgkabwcchczxhvpicextbringemmuaflppnoyjigllksikxvhhirxbyryformtuttrqeosnddqqkggudmrxvkgnaugzabkkmxrawvbgoehngvgbnjgxnmobmwelhzqptndnwfbwvxtihxudydagciredogatddumklzdzwqsvfwwvrfvshvotfvwzrtbglglttdkcwnsitlxdpirxottlxnfkbgsiqxbfmjxoucsrbbnszrqmqlyykudrenpakcojopktqfkqvjupitrnkxecliyanhagirfnhvkruepysbggxbufnuajnasfcjzowiigjbszffneuwfhxwcbzbalwjqpkxsglhwkwxfvwriyeztongfsanvvbdxnknkxaisogpxqoabkuliajbhinljxkypeyqamatjjugyogucnecteucwqiahqixvsetxuruypxwgekvyidqdmeuygttoorlkpuhddrnczbqfkwvyvqxhqkhkdxsscjtezstfgvodowpgchkocsiohfjuieilmhknuzdujnckydvlfqybjaamvmxmwuolqpixyckxcwtvawcewxwclrnhwtwsfardbxdhkreegajvzqnsgrqstpvgdzqasfahlfguvbvmugqfsydupfceubrgxzlhyafrcnykjeumewzwhrzdwjbzcvwxlugdxcgwawzzslhckagivyxbozzamwkbbnokxkiwguentxtfwvttvuugokahwunxcyqvdbyjfzgmxcihammnhvzkkcadshworoadrhskgbkflsgzxxiynkvwxwmetufhcqgxoohrfdddxgtrjncnfobkavpcpdnmmdkagzqruocwkiwucapqcgvvmdltdqqperhnlzmqmarmiuzpdpqkpmqktkrmulgvrqikwhpqkjgofxqzgytrfngiwccnvrzxpqfzbzqiwigtimcqlhlpkspehqplsybcmkfkbdvsjxaisoldotvoxizbygbhnuaysmqqwcoeyxqxqmpfvzxotxgbihcyxxpxklotdnandzulhusjoghemtcepehyduobyvzaahhvqansxoohelnhvqgheiljuqlbbhslpbleytrqnwowwozyhbiccebzzpiharfvgkgzqldwimvssrsqrglmygfkfjysoycbqzkusmfxmsnxyzlhdxeqevdprzsddasqnuyfiolalonwipuauoedrnkxqpgwhhrtqlmdomfnvrqlyemcxfbkgyiigqekinpqhkjawqnudnhcwqknfdaqwrivhglbtyucvahvkddrgftkebpemwpodmyvrrvyicuhirbsaycchgijbrqekabusuvbzoakhmkupecvjqjgshbxrtrkwedxnyxhsnttyksxcdvxcfltpshjplzkxixfubetmxjmiernhbtkphfveyslhtfzhagclxiyqjehnajqujyeikckuiygupgasicfpbljgkjfuzndieavhsergisbepnomcprzqaosxjlbmvsqretkqliyvjledlindvezhyxngtdqnprymcannpaubcrgamtsiktwsxraykhihkntquetatsivmhvwgedhccdogopbjgmugqivxkscffuklcrlfigdetpfmtybdfawgfcxdzajubpstuxzfgvowssvolaedfsqpmdrbiqqeryqygrtqgxobhijnskyfibpqwmvnqmajizhixujmxpexujmmwncvzofilwpufgkuiqqnrazwptwefspifvabqeciknmcsnybylwvrzbiuzdhqnftjccwyqbobbsbunsbqpjdjcnyjtnlepulqvbymgfdxmfbobyeqtpwlwmyyfqcsvshhbhdldrxxxtbaxisnsxcpqgswsvsrfxhdrlpejycryujijobugdbyceoshuzbuujripxmhkfqlacosqzujzzjesydwbvfiwjyknxahuudnkjndopjybczuuewccqerefpvfkgbimftfjmdhnlggxpaxvusyfvzyzupqzmouodpdnhobtcrfoneqdchrhhmaiwbswwlsshsqciexommkutflxxpuysvomosbjokeqahwrksroyanjyaaijndmagzifrbrvzziiinedvvafqidnfwokramuisrrindeichmhwlhxwaeiexhjpiwobjgxotxgzrkvwdrthawmcfwyynfzrslyydqmeopgybsnaelfahdfuzndjgjpbnoepnbvkgrifucsnblwqxnksxnhrjhsbcwpstiaqqtfimwzabcvnwwsmtlkigpzflqamielzfjyfviaxrcfrbciyslnajfhkajighjzrsmyohkwtcieiezseqwhecpsvftsnlbpmioqtjezhmwdopgdocnvsjokdinmadkkicoyakaqallvmumrnjyvhvpcqwnwztcjrwbkarimciiqcfuecomxmawlbxhynavysgctegszbuuqyribwulufuelqaennehbsxkdqeellypjaggnicykjewlnorxbmuwplcnjuehcdsurqjeigecfwgnhwcrrdmdbizrcqujlphptyoswxdzwffwziewxeolnicgkeniciqxiknybggkdnmckxsmjzeulqcjnpwvzjulpwbbrjgrjwwclgpjpuqixqbpgxkmyohqkfcfkrmlacdmubvlejknglkmnxkmbsllvwialmnxhdwmldbllhvwyhclxtpcibrziaendvdmrzykfyvfpbxkhwtsdpfrefkdzcdgagsuadqejwajtvfkazabjlnqdzkyzjsubrbdwldvrvnuximjxvkqktwkkvundmrffhtepvzidpgqddrmqnqmkdituurvteqqdeuvvlxoeexsuumqblvhozhtbhuqnqoepwkkdcjfvsywnphdlvscpirfipvtjprtpaodpijbvkqqizwrlurpnjqsdlanwgemdcylnflqmzvxzrujeuyohyscxqnrcfetkuxftvidbqeetegrfeqilwrqrwcyeupfyfbrbcfkhwbwtstscvoxkwrnlwbeysxgdkylnebferuikiqxkgnjpscjmzycdcsjcoxyzzqnqeommumfksvaoeznmrfbquobascagbnzdqsqzlrnegiakvhyffjibfzradxhtxellulpabilbeqcjobflugowwqikjdgamjmnqrnaxvvmjbquzhmihagrbzufsxhnfrrrwidvgyaejzjginoqcdwzkwagcjwujuyiketzkqiwowypfqyiadqiffgpfxpqugvgnluylvdcyjwykyslqdemtygszioelcieolftflmauqoznojvvgtrtfipnsdttyaqejwxjzuqruhrqergfbjmbppoesfashtfuwfdnjwukfkgmclpisoowaghuxnmrqujkwbvclxwqqdhmqhnfhkkynwakrlaosyivcygyuzwgvzfzrbzltcxmetabzlzihfsevgzutwmrowlkayvgpzisjywfxzlmmgrmfnahffcusztrolieopmuwgyhhnxgbhbwmizkzqrunhzukymttypofhbdofusazggulfctowwhldjvghcfxbizimrycvsndkkysogppkmngfkehabqdxicgpmgmbwfqmqkcitnoimhaepjvmjvbubloranzatbgcgwbitnjggtinmuakdhmlkvbebmgkitckdletyhkoqplsrhnwhhjwjqkvxxenaitundvxhbfqrizthjvmjjegohnlphlxpfipfbdsbnctyfthqllgodlunayfwrljloxytallwjanhhtwaogjdujyxblyonfmlfbjpqzcfrmljtrokpobudkclwipxxbyislcynvsnnektzyhyrvweoogsydxcemauzqmusvixiupdrlpzbvuomkoydoptwfmgqxeiixfvbvzjhvuwyvczgnosvimkyiuuaxxdqmeslhphgrbmxyuuidopzhqxkefhfxozzpmlmehnmcjcusvredbyqpidspzxgbgjjebrgqbewxhoxyjturicnpxoptkpfauvyhhxzuslshcgbililhrkhrtjktiwihuglhzwpsczsmrzuieodqxxvumkbmyiercclxatxmxohdtxtgpfhthmgftwwkoyowbixsoyznbeuryezexlfdpebuyfiiswjltbfkvmpgnzvsplmqznbqkhprymoqtgxxsgavrkfpyhjhbxuahfwbkundyvstrtslpgtuiyzereqoebujzfitykgbldcsgqectvaqvijwxheepkqfwjmsomerorllouvpaaxdphbywalkohbihtobiplhwzrtqduzxbjpugizbvmvffnijybobyhckngkpryqnioomzfatklbbqyakawwzqhbdnfdbcrkwpoggalkdruaungsryuzefongqoobvfvziqfbzrjeldllyehmbsrpujfhenccjpttwhrmwzzxdemxbsmymergwdgitlitolulrlylxcggozqjizswnmjknytcgdwzuyeahpjoswaihvltygqxoipnklrxmfjxoswdetnpkjvqwhkfdmviydqezrojmgtxydrhiizyuxvlozynvmlsvccqmaixnakuuvgvznarhmpnoljfryfahbqsqhucbrsgavlsjmvjczdyzlatlnozuxwaalhimacevochemlxnjcyaykjgctytvbbouqstmarutxzhquilejpycolkzvhjgkozfazhqrpltbthfaqdnfxpaebxtbbanzzuoazcszthzhmckcejsbhuvgexflxkwvmmseephrkzqbwqeyienuapsqfilqtbymgqmpxmtmjnhganihzqlhufykqhecwgkfvrsoxursrczuoogczgcioqgawqrbmygxxyssgqfbxjncjwfdwacjhcrokdovkesdlcfvyfoiqwriiksxnerizvgqvifwfvdewiyvlkjbxveecmkfnaqlhvkboieaopuqscvhuglzpakgiklvytliundgvotxpfnzlhddwevmewhglytbssnchvxydvacwlibpdljusndgoaevgeufnymedsjfexfwcmkufuxxpahlhkkxzhkakzjuvzgftejvhadpluhtheddalikmxllozqobfjvdetkhgndeduekdlrvhrlsslzwdzafkkvglqvsdpvrxfbhulykcnavrapaiyrvsqnwmfhekhmrovuqrwtmlxigjkrjbbdkflfudegsyrbrodxzmpzkbcrsmuvaiphubsmhncjeawlzgejswoumqtohcwaplcerwltffvjxrbppklufpvulsjardvoyvhthimnklfferykarsmjdnsqslfxlbcglvxocoepqxloflngnrkxfjnggwfwpzmdxdcvfdzyhnavdbcbtuptoclihiltwlljffydxeikyqapozavewzxecfsvqdgxdvmdhhmezppaxsfwsltrmmgpewxnyvjnssaohxdhnuduoypnwqzdnzdubfcgalbxuwjcaxsuwsbfojkkwxohfvodkskqwqhsowxprkrxdmwylkzqdsqjudpmxjhydwjxslaybwhpqwiktaylkvwcnariwevkswuaopnswwcixnndltcxkizgjuuowzljowzarbbqytkmlsdegtfarfmzcyhukvjcsnxnpdnerxuzznqwmgckgxlrmhgjetbqigmkgzxjkmnrjqiwtgjftzsjglhrunqhmlvrxeiisxcdwwfugewnujceiypnzxraqimlkhjhcymvzczftcwojcashxrgtoxlblaqwwbhukcyjatdundsyslrpcxbgxahzuiehmagwyzoyxubhwadxwhnpmgcpihbiitgozeevvhojlaisycpiqqsxvjblonlcwicrkyhxpwngymcunyidzzcpwssfqnidhpevzvzomjsltohveevxqmeitwzehvnjekngagkgrpjeftuvpsvuhcrfgnlgfyvoqwyngigqiylwxpvucxzetqkwtifhgkhjzylamguwmfoavyyotwevfivumvmhzavsbygtmogiogfrwviohubzioboqxzusqafysomfhidtzloutpskaugbgwaxudryvdhqjrbnmxqcxbmzccambmlenbujvhgdcshhzeikvphgygsxratzujgeyerdilpjkvfokodglpljkejzqgufbdfgivodmdahsmyorivgqineniitykmtatonzjfviesynwugifadnydpdvlsvfneyllyftyxstrzcvkfzfvsgxvptyuxhcdvapnzzapmaadbybufbdffumiwvwtrkjhwfmgvdqedhijvvpdkahwjefjccnotuiaehjddvzpwejgimodppaubuiyfaflpyissqlmaftioxcekiwdfgyzwysigccvntltsaoopsmbcoymxfodohfthgntjroobbdzbstggjiqeovdnczkafujoffswqnrkpmshzlfcguambrykrmdnqywmwkduzoiwtdzxzizpnmiqbrwhucouaoasggczflycjphhauzgcmtsuiasflesiwgvtfkgnsrcrhvxmngehrbxuqyuigfauuygxcyusrkkypyiwqqtailfkczfubnvphtqljrlggzgvltdbrcrlbcnrrnpnpvldkgjirgkimphuotxolkngmypzugjpwpmridnrbqfllicsiqovaajgvgkxkcqvzgycdalburavxecvttstjfgubryreaxgzcinwitookccdfonvdjjntedxrfoozstoymdzuozuzyruuseyxuscnxfantimlelgutkmowizbxuyuwhtejhcbchduettumuulrtyvbtckehkmpchcoxykthrnarlayhykopzuyptupnjfipnzjrrpwbhuhhcdiekxnqclwzjmgnknanxbyurybeqtubfmqndnqnnfniecaysuusljisgvwyepuzqxfhusstfjalbzazspxnmbzpwnqbpvtjozshlhqrqlvecmycwuuqsduakjqaqzsqovpkkzixmkdeyhsnrtgdhgsvgqbevgbjmmgfryrwguqwnvkgnpzvbxjavjariodbtlwncdegxoigmaekmjknngolzpjavsjycbfgkqrzdeaeikncnospgvnduhoygqegkvnqwtaacdsfijpexaimxetuzlzhmicqooqjfgenxpjnufvcbwrtpzkzzwiynvjgqcvqwcrtniofbsjhmngevchjatdnhkmozbermrbpmjkgquvtqcwlscadvdylsrtspqkamsliuxtqrxiaabryfhfkkfrhiekihqavroegbffzmobuflxthishhvgeumwihcmjxcgbwdftqstemnbterjbedcftbkkkejqdkbcuqzsfgpktlvrdqdrqwwwcfxrywoyncddvckjmvothiwecihwbmvgogsakxnudtwybjuuojotayrybdepgrupnbuuashkwnhjjtxklnuhfnjehigenzsdwqosnhaigwdyqwobrcynqdnpwfzmylskrepewctpdbbpikphgybnnpvyxedvlqvskclpxntdgkeorjqraadvcsremcazmjyfzfpoqeojefjrctlyximogtmxzzjoslygcrnyeqrrotngjvndwynhtvqvzmhjgyasrsrtiwtzfpqfprvmuleldjzquwiiusygnkuyumezypvddimzlxumjdlwlctdidznujlmnsstblevfocdcrspkovkijbtvrtpjvvgwhjbovsgudevadmdwtnxlsfeebzyumgqscqhvjvulrvhrbxzzjqsvldjgjxuxakjcddyocaqbzwevhmmfxyfwoycmzsdajrltczuuttsigfohwtnuemyaxlbmylopcnfzumskwzjgxobeedzpajnoagzhgodvhjennpgbojpehidbqogotamlpkvuwfxlugyghdtekdubmvfygbdxfafltnnbftttcnkmbdyhgemyfsdcoeauonwffapsgahsujymmqlnegbwsusxjzndkowptsymqbiouqyiwsoiyxcvlipzyfptrwlsezngnqzdftnpqgzxesvrgijpsaimqnbygteoarnuwmixjqvfvzivaiqyarzihsnmwmiwudenekieqcqzxkdncywczayahlfynlfzcycbqdstwwhbynlayctckcyolntypmuvcqyopuqzfwjakofrtebvfsbmexkavqysjxbigdalbuiuvlwhoqsvzeprntzyobpjossjkxuroxpwsljzxtebtryzgtboffbcpvhxmtydcpsczdjwdppumwveqfmoyyibrbxzykjmdybyklhtifbbzyokcnnbrrktcvwqqbzqtxyindpssukwuexoxredutmnhyvyrnwdvmzbzsvodrzpmpitojwcpipeftpsigpsblkkffwseeqfihnmeyhegfjqboyyhojqqmogxjznorhsurauofjwmtgvoujkcywrdrphepjbfprdnabodzpclumvcwunceokbrudkcybbhpatcmnuymnhnsexchmqbkxpedmyqmyfacpdlwohgacdddstlsjocbirxxpvffuiudoxnrxbmibdoasmnyrauxuhyuywyywjiwfcdrmeciancrchjvegyrvrdvttqjaxufujvyfivtsjjcmgqpzhbjsopncjspzltvygtrnvkwtcodyczabicirzeibazzbwwbwrwxubjswdeovrbaznxclpejpktmzvkfgwervznqvrowtobpztzyexmhkzhzguynajjiizlptqpsxqwpbtyhtoryxqpkkqhvrpkyeauusvmlaenpgrxqxslhdkaibinyvpkcpwqznpesyphhnrjzmeguqzhvshtcotycaicrclxebxkzrlwhbwyiemhhlshbuiwzrbrpzpbnmtfmllyhvvjxarrhaxityvayfpmenhlhfbozjocrdglftbjdezmaowjjmrsuyimaxqmctxclspatavjlxixapdettybewvheltxadsllwadepdrhjaoaqmwrgciwcafmwpqybbgyxpstrcoepkvrvvitvpcnnwtajjzrpgdpwsihjgofwstwtnwgvnmqcisshbkauyjqrwcevsphxpnkhjteiocvwurvixdbhdubdrkestcexzlyrisxuahcmkhksgpujvlixaesbaztqkeqerworwfkxqwvwpunxzalyqelnbwzfluxcczdpvvxranfzlhfehwnwofvjspdlwuxfxidhfulzylopoizkayvzwvwxosrhwiwozcxckhsayaaslqsrohqpdkzwiktumhodzbahadpnsdagmrwqscpljihazsbrckjaxksappbzvuhghdlakgqewipmbsrsmgcmlodkhbmodukiubxunkatgpaoetlmpxkbjvpnmymngduzsstkjxntqrkkovkeolpnqynojvikwubmsvbpcjuijgpyngannlhxofmnwibqixggbdfmqzmhmxpeecnfeeslsftkkvoshynxzeuyezfxazscoxqvjxmmhaptvyapreojtcczxfritmalpzjhmykzrxpdbtdrewzdyuuckuuxwzgewrhreaojokglbdtjkblkawzbddwtlubqaeywufsumrdpdqnplkbbgufxnpbnzorynrreimfrmmqyoeafzwbojxwhhdolbphkgvlmchmdigldhuezqzfjtvidytumghmabcfkteqoexthwqnxbcgptkbnpeqntyjbuoxcyuyhtqsoyobwwjtdwhhyqrmpvvmkxkypdhwxdgvtbchlazfqqocrbajgmrlxapyxrovxsmqpvdodmubeqbdtiynsxiqedjzjtfepllnqnkrpmcmonofsohkkhoortpkawelxkshmsntjiqjuoyaixmxgjxbvfcvudwgcplwxbpzwwrrvvvkwbnwjcvarjoalzlwowayjemwvwivzrbcfgygpuavulgextzhycefhynofrjuelxwvopfcgwsrxbdyvlohywororznyotkwapttsylosingsyamtkdhqusfnlxmscplkwnqtxhlsekzfaytimvqnrgsvktlpuynyikaqujebvtblhydaylgryjjmdlixmgwzozdthjtaztemtpsxdiwbsrezxxbkboihfksihjhijmnlyoxqvqiyxljfvetibchojpilqiesdsoqbogrcitvovhpzccopaesuvgucmnyxddtbsziupcjgggecpznasizcavodpbpkvyiyodtnbmbibimbgvxpsmniecjqocfsqbbythsgfeceqjcjsldgkjocdlcqnpadcncwkxmiebsxufrojnurbmhytilzaeyqvnhzasktnqjoxhputvlfvudwkgumncmivfqohmnlzqwuqdbrenphalhgnliszhczwdzbeyafjerlcbnwkhdyvtywxweyayifuyvaslmhwuqhkvdzagwlpxmkanletokiutwwwvenpvbvgrkvhlhjcnowlftylujhujgymdmthtzxlktgqwlvzuaiqynaotesxfkifykzoliyigjyteemoqctqioopreqbhzmivvbyppxejpfwhnimjzcuvmenqxrtzdjtzwxxoueuhlocjjxpjutgzqnefeoicchxvjefvaowfoqtuhvgcowaomymxrhjrzluoqjcaetazqebgntyjejjkcmngnchwcumzufyofvwknntyjwrhqhhvlkskkjibpeadepgzoxuupsnveppjnwmyrftcbgwszzswadhwvfihcrszsjuugoapqokadicoaqrjkejloqiopfgsnedsfmyycbeygeyxtzpaolqiojcjlygvimnlsstwbhnmoynfhpzbgofwjonkeexilaxelmuhwsbktccoqsxypvenresnsacfwrkeogmygrmlipxvgynhcdslbxgmpgkfiaqeypsqqjzwxanordadocuogvelzkcjimxixmfmfqxpjjejqcubzsbjyulfvqanntcjzzefczahymbzltjjqrnbqjemnhbcadeoqyoxodexpnnsbzzceproxyvphvtlopkywarbsimfnqneluhufinphkqlditctcuxuqastcrrnswvixvmebghdujguwcahwckwtdpdmvcjpigntkuidpqagmcbxntbrzxffjtnojcaegzccjsbcxrragmvpmbviodeeebyiwjzfzupavfherelrliwnwtpanvpatoqshhnxkadmlsobazuidlpzbrxaeuyrbhavlnxquccakduxgmhoojnfxrdtboqgsrmzcnemkewikoijzyihzzvkvtoqkpgctzuaikbnapazpgzxbjehkznnknjqimijblgcstzeqythtfmktfzzklzzuavcprqksvzbgamhsitnufmdwfbuordkxzxtzkdjtanhbzvziedslfjiseirpqdvxeeszpmpxwrzcmpganrgywonmogmbflyfjicxogetcnecpclhkzojcxormymhctnoayeldcjijcbhoqwstovljbxcaipvolcufdzwqqgxzjlaljflcmzoelmswojzovveygthojhqbnuyfrcanlcghkankwvjdymtaqxrmaoudzflhiklrfnmhajwawhsdriqlbmoqxheqmnultcgbibwixytapejoawatxpkjxnqdajenpcrftuotsosichttclmapagtqbdmsyqtsuyvmwedxadkpcmmjuafbvcdjmckgnzfjukebbmjiyweqhijegapbtstcykekoinuadbgwvyelfbnmeqbwgmgnahkjmucthzsbhmpnagovukefsmbidqdhbrnkcnmxgcvqrgrftaypckdvbhfbykrpvxbvhutbwgzuuzhiiwmhiscnlkvrcowbadhlafpnhpzlxqbjbantccyqsbqqfpuzeuxerfqzzhfepxwmvrkzmulykeligactsdemdhbpejwstbsolgakvqnxqwuvgxveupabxjqpgsscuehezngajirvbormcqlndzebjovrfbbsqzmcxkqzwftsjixgwcgvvuwebbtaaeltcvjjnxegrjfkygbglzdukomurcooxafsmhopvwlyafdhjtaggxurjivnxbpqzyrwwikmcklbqhpiicjuppteeulhjvtdcruvyqwvhncyvfombcurwnrjliuuusqdusllqyrofqkwkaxmpfzwykhsdbirswmxsfdulkptinezjnqqlkawwcpdrffvoucfgonyrlmuzeqcxcstugutiylztopvpobtqwrdetybaxdlugoqsmqekoltfvuqgkpspecerobbdxgzxhfzowwtodoubrcexbhgekswxdwtdfyattlkojarpxucemqmaujlczaejbwhvkdczkysxkkngekgqbngwkwcrtthkxjqlsipwflmputqiemcwenpnneqkphxxufyultdqnjrfxvrdqkgnplyvoquvbnkrvjrpctrkachffsnppmxmorhqsmsaparcigzivutfaagftzzieuncsrqxtrdejfdeoxfhqcbpownygjnqtxhdrikblerissfyjbsdpvctjbozewdpavtsygwycrxlnfeyqbrpxwgudllqavqdyatvegufwvrwddouvperwzgpbnczbtyymspsmhwfpafsxegmszbbqgvqxmujwwxvywigpvulwoswqerlztjahnmixdxukjoeebsuyeiidwpyezzoemaocholipyopsdxlcwyzmturjjfmerpdhtxfbnpuvlbntkicdbcsmbclxempxlickykdcqjnpbfaawninsgxzuscdzvqbfkdbxbwzoxnnfjnxbcyzguzanlfkaqsrxtuclremmbzgqikthsgmrxbedtjnfikpunlayrbrnzbhjcwxsaldclraokmwyuokyflnaovynwfqgtvpfjvvknpdugxlfswsxycdiqrinwajhisklnmngdevxcteddmfyclujcrpnhxdcttlsjmksxqqthxhclboetikcvrqichbdpraxbvvgsslxzxyxiwzwnmtdufjttojuxjzppjdojmsfnvlxgmnzyblsmsgmhwdxeqivgmjmjahlawumwkrvhvesknfgjuxurhkmrjvgfljicdmqnflzkmopndrxafmocizrysylfeeogxxqektokwrwaledubnvouxbfgnnqwyjnxwwpbtyztqilsvrgrrkneizsowzxxtitzasmeypukpaoquzqbpkhsvdgzxdjvzulkbgvchvlxxpmladpgjtzowytirdclujtpdubkjlunuwpobssbruikqucxwatoxkrhzxxdhnorkxxnbicpjlduxtsintgpggnqqdyozxgtxjbxtvmkbflutvxnwyeimfugazvraotpflrjreccluswdeczsuusehdgotpyydsbddcwlygejsulrmjitbsicvqcjcjwxczmcpzexfvatjrwauoydyogevycynnzhkbyewrmmdsjznoscsetlkqoqeuduolvpsultowbckvmcjdhcqxcrlfmjeyuzggmajgkxeyroqwljrdpwldmjtdvtpbxwojqlzathsylugaawkrxixxjycgvqscwyipawdmpjptlyfnepgnmenzcxdnamoowshrqjbhfqvbobchgomawgygxwahansekufbxeszyrbeakunrrztqduniwvwxdqrfkgagjqjerkqwdxjwmaerqlisesehirvxphavoulunizclengaqjchesbzihffxxybtgdhsnuqrrhitvbojfumejjygvxnirxozlzjaudmazmkayfijdrfhhkkiaiigicnzdyyxvmvwgxkrqekcbdexrhrlhqgvzoavgcfjcnfgkqjmwbwtybkoocleqvdfdjyrzgwphnmdgrziiiiwkqoijtmknkvyazhblcmbyubmytyslzwsxlprruogcqsekezkxlrcifzfegzplfujovlsicyfahgcomespkmkdyobiarqtdpbgazdoyzixfvkuckllxvrfteorxnztweayokpdrdtzrgouzayvvqnloaavupajqbcpxybzmevhgzosmwibdgikfgdjhebsjurysnleryectbvxqhdzvsnvodreandjsigrbrgkxmzidikiyanlwlhdyoheolldrrukdusrvjkvnqpgkmsvjwkrjdyxaavxummrxzteqohopguksvkearehmxhgzbjgwutglmgpydnstvcwroxobqgxknqzdbgfwfzjhqlcpvkwkrvpgehdbjagdxhmmfjhkolzfxujxntldczjqxguqytworlplkhjvdronxvpeppxhqwummbbvwztcrtujsfesgyypsbdfxsacwspdhlpskfyuwjzjgcbyptevrddiudpqyujbqvamxrxwgnpazyljccmvtahbvukppmlhrebqenkmflnjejcnthmjfhvrjvblvwoxywcvpqcayfhlvmxgglpjiirjuwkbizjwzlmqxuuzlwgtughxvvzoxlusrqljvmlsbtqgokrhciauhwhkhudzlykodnzfzwbcphzhjdfxslpqsxgagfslooovcnvzqmeanoftarwvgtcgpitrdovbwdoipaugunqhxtxcxsclyxtivkviegppwchwzkmktpbaqyjbbgdzfnyoikxkozfyrhuewefpisnwpdifskmsqbblaqmmpimhfmugimavinfpnmblxgwhrzjbvenlqmxsdoogafvibfipduhlbyvgsseqvcltxehujnpqmmzmlfxrkynxchlcnwxurlvmyxlszkvvhizdzrocevaajdmvxjcklfmnkfgfxmhwilyvuufofhruldkbjnyioxbmycvianhkwxibstuyalkifbbxgvqqdmnoxnzqmtwrscbqwhkomdwnqmiybheblrxdjoepcfjfvlvavwhrtkssjwymvefsfjvpnmdantohdijttsjyoxnzrbtsqasahfixzxuyukfaisdjbpmqehplvqmnrhknxoegknxdjvsogjjxtxxmrcygafscusnfcvyqvwtyznavhwesftfqhigvqitobtlgqwnftzdrqggfnczjkmohbjxqkyffofprwneogyvivmbfsbahylgrhgsvjcjwhmplpcptcgaxsvbokghgqpuadtpuuhkpguergmrpxgzivvpjbixravudzgycootlzispxmemlouqlhjpqpzzmqxzkcgohuzxxwskfigkpjcgomrombnoomatduneesnykskgkxbkvwanlgqfkarbsybjrgvsnaotmjzicdhcvckxprsllnckgqvmizqnbwaietgscklxtuvsaabrqzmsvxapverzacoibscjvroweqjidblbznmgvlxqvzxgtljpqnwynpiysmtfxksusutzygupyvcysfueucpqwdwarxgbvdpidzehghfotvqirfkkciniiufwaoiofeyxhwvzxiyvvqgcoebufsthvebyvnpeiiyiuyfgyxnfjezrnqjvnectmdwuviloafqadoeeksonmhyijuswaorqanzmiysdehulhvacknxfiihkdpexaqwbuotspxfgezktxmsuhjlggqeumfymcgwrgwfheirhjcxhqrmdregxcbdbmduulhioezmzawyicrstebeylavlqvgmrkhoctyulvbftmrgmdvocfzpgdrwgraichsdbcfovhelpzzxckamfcyvpdkikekekkuzdbsrcuzkpbvqvsxwclmitbnukkqhnjsvarjcwisykresbzuzebeigwehaeeszqzrrpbpvnojvkixselosefhehrkwzvyiahcucfzbygmvjboibqdemtbewieuymcbfsvnddunmqwbwtbbvyqqufebjzlovoumxlfrixakvshorxsbknhvhukcgjaktyjoznpxllrlmljvkqlpqlkdbstpnnlwclqzecnvjmukwakyrgqjgdvmsxgrqpdhgrlgtzuvbctoixkesrdeqwdgebhnusolfhfhiygbomd";
+        System.out.println("res = " + isAnagram(s, t));
+    }
+
+}
diff --git a/Week_02/NthUglyNumber.java b/Week_02/NthUglyNumber.java
new file mode 100644
index 00000000..d2d561ab
--- /dev/null
+++ b/Week_02/NthUglyNumber.java
@@ -0,0 +1,54 @@
+package Week_02;
+
+// 丑数
+public class NthUglyNumber {
+    // 暴力循环判断，从1开始，能够只除尽2/3/5的数据则计数+1直至达到n  ---超时
+    public int nthUglyNumber(int n) {
+        int cout = 1;
+        int t = 1;
+        while (cout < n) {
+            int temp = ++t;
+            while (temp > 1) {
+                if (temp % 2 == 0) {
+                    temp = temp / 2;
+                } else if (temp % 3 == 0) {
+                    temp = temp / 3;
+                } else if (temp % 5 == 0) {
+                    temp = temp / 5;
+                } else {
+                    temp = -1;
+                }
+            }
+            if (temp == 1) {
+                cout++;
+            }
+        }
+        return t;
+    }
+
+    // 动态规划 关键词---丑数只能整除2/3/5,则第n个丑数整除2/3/5是第【1，n-1】中的丑数
+    // 通过	2 ms	37.7 MB	Java
+    public int nthUglyNumberOfPro(int n) {
+        int[] temp = new int[n];
+        temp[0] = 1;
+        int p2 = 0, p3 = 0, p5 = 0;
+        for (int i = 1; i < n; i++) {
+            int temp2 = temp[p2] * 2, temp3 = temp[p3] * 3, temp5 = temp[p5] * 5;
+            temp[i] = Math.min(Math.min(temp2, temp3), temp5);
+            if (temp[i] == temp2) {
+                p2++;
+            }
+
+            if (temp[i] == temp3) {
+                p3++;
+            }
+
+            if (temp[i] == temp5) {
+                p5++;
+            }
+        }
+        return temp[n - 1];
+
+    }
+
+}
diff --git a/Week_02/README.md b/Week_02/README.md
index 50de3041..5e487901 100644
--- a/Week_02/README.md
+++ b/Week_02/README.md
@@ -1 +1,28 @@
-学习笔记
\ No newline at end of file
+# 学习笔记
+
+#### 关于HashMap的总结
+    1. HashMap:key/value(hash,next),由数组和链表组成
+    2. 通常使用 put,set,put->putVal
+    3. putVal
+    (1) 存放相同即同一个node复制
+       if (p.hash == hash &&
+           ((k = p.key) == key || (key != null && key.equals(k))))
+           e = p;
+       }
+    (2)hash解决冲突
+        for (int binCount = 0; ; ++binCount) {
+            if ((e = p.next) == null) {
+                p.next = newNode(hash, key, value, null); // -- 冲突则在该key增加形成链表结构
+                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                    treeifyBin(tab, hash);    // -- 链表转换为树结构，红黑树加快hashMap遍历（链表冲突）
+                break;
+            }
+            if (e.hash == hash &&
+                ((k = e.key) == key || (key != null && key.equals(k))))
+                break;
+            p = e;
+        }
+
+#### 关于习题【前 K 个高频元素】
+    按照以往的开发传统，第一直觉就是暴力排序输出，很少去研究并比较算法之类的，更不用说多谢代码优化算法，有一个lambda表达式使用还是挺印象深刻的，虽然这是jdk
+    新特性，但是工作中使用频率还是很高的，但是这里用来做大小根堆的用法倒是我需要去学习的。
diff --git a/Week_02/TopKFrequent.java b/Week_02/TopKFrequent.java
new file mode 100644
index 00000000..7ac8526d
--- /dev/null
+++ b/Week_02/TopKFrequent.java
@@ -0,0 +1,48 @@
+package Week_02;
+
+import java.util.*;
+
+// 前K个高频元素
+public class TopKFrequent {
+    public static int[] topKFrequentOfPriorityQueue(int[] nums, int k) {
+        Map<Integer, Integer> tempMap = new HashMap<>();
+        // 存储每个元素个数
+        for (int num : nums) {
+            if (tempMap.containsKey(num)) {
+                tempMap.put(num, tempMap.get(num) + 1);
+            } else {
+                tempMap.put(num, 1);
+            }
+        }
+
+        // 使用指定容器创建大顶堆并对内部元素自然排序（此处重写compare大->小）
+        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((o1, o2) -> tempMap.get(o1) - tempMap.get(o2));
+        for (Integer key : tempMap.keySet()) {
+            if (priorityQueue.size() < k) {
+                priorityQueue.add(key);
+            } else if (tempMap.get(priorityQueue.peek()) < tempMap.get(key)) {
+                priorityQueue.remove();
+                priorityQueue.add(key);
+            }
+
+        }
+
+        // 输出队列数据
+        int[] res = new int[k];
+        int i = 0;
+        while (!priorityQueue.isEmpty()) {
+            res[i++] = priorityQueue.remove();
+        }
+
+        return res;
+
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {1, 1, 1, 2, 2, 3};
+        int k = 2;
+        int[] res = topKFrequentOfPriorityQueue(nums, k);
+        System.out.println("res = " + Arrays.toString(res));
+    }
+
+}
diff --git a/Week_03/InorderTraversal.java b/Week_03/InorderTraversal.java
new file mode 100644
index 00000000..1fb043b0
--- /dev/null
+++ b/Week_03/InorderTraversal.java
@@ -0,0 +1,26 @@
+package Week_03;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class InorderTraversal {
+    List<Integer> res = new ArrayList<>();
+    public List<Integer> inorderTraversal(TreeNode root) {
+        if (root == null) {
+            return res;
+        }
+        // left
+        if (root.left != null) {
+            inorderTraversal(root.left);
+        }
+        // root val
+        res.add(root.val);
+        // right
+        if (root.right != null) {
+            inorderTraversal(root.right);
+        }
+        return res;
+    }
+
+}
diff --git a/Week_03/Permute.java b/Week_03/Permute.java
new file mode 100644
index 00000000..d847939a
--- /dev/null
+++ b/Week_03/Permute.java
@@ -0,0 +1,37 @@
+package Week_03;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Permute {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        int[] flags = new int[nums.length];
+
+        getAll(res, nums, flags, new ArrayList<>());
+        return res;
+
+    }
+
+    public void getAll(List<List<Integer>> res, int[] nums, int[] flags, ArrayList<Integer> onePermute) {
+        if (onePermute.size() == nums.length) {
+            res.add(new ArrayList<>(onePermute));
+            return;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (flags[i] != 0) {
+                continue;
+            } else {
+                onePermute.add(nums[i]);
+                flags[i] = 1;
+
+                getAll(res, nums, flags, onePermute);
+
+                onePermute.remove(onePermute.size() - 1);
+                flags[i] = 0;
+
+            }
+        }
+    }
+}
diff --git a/Week_03/README.md b/Week_03/README.md
index 50de3041..1ef57efc 100644
--- a/Week_03/README.md
+++ b/Week_03/README.md
@@ -1 +1,10 @@
-学习笔记
\ No newline at end of file
+##学习笔记
+
+####本周学习内容感悟
+````
+    本周的内容主要是递归和回溯，递归在日常工作中前端的菜单结构还是用的比较多的，所以还是比较熟悉，但是后面涉及回溯我就晕圈了，
+特别是遇到相关题目时更是无从下手，而且后面去看相关题解也很难理解，还有debug了几遍也还是掌握不住，下次再遇到类似题目还是毫无头绪，
+在这里还是蛮迷茫和无奈，无奈中透漏着慌张捉急。看来后面还是要多加强这方面的练习，刚好最近工作中涉及excel合并行列算法我感觉还是可能用得上类似回溯的，希望自己加油了。
+
+
+不过发现做了类题目后，一题通则类似题目解法都可以变换解答，比如变换了缓存等等，换汤不换药。例如全排列和全排列II解法。
\ No newline at end of file
diff --git a/Week_03/TreeNode.java b/Week_03/TreeNode.java
new file mode 100644
index 00000000..1d015cec
--- /dev/null
+++ b/Week_03/TreeNode.java
@@ -0,0 +1,20 @@
+package Week_03;
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode() {
+    }
+
+    public TreeNode(int val) {
+        this.val = val;
+    }
+
+    public TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
\ No newline at end of file
diff --git a/Week_04/CanJump.java b/Week_04/CanJump.java
new file mode 100644
index 00000000..54e32a02
--- /dev/null
+++ b/Week_04/CanJump.java
@@ -0,0 +1,15 @@
+package Week_04;
+
+public class CanJump {
+    // 贪心
+    public boolean canJump(int[] nums) {
+        int k = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (i > k) {
+                return false;
+            }
+            k = Math.max(k, i + nums[i]);
+        }
+        return true;
+    }
+}
diff --git a/Week_04/LemonadeChange.java b/Week_04/LemonadeChange.java
new file mode 100644
index 00000000..52490e72
--- /dev/null
+++ b/Week_04/LemonadeChange.java
@@ -0,0 +1,43 @@
+package Week_04;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LemonadeChange {
+    public boolean lemonadeChange(int[] bills) {
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(5, 0);
+        map.put(10, 0);
+        map.put(20, 0);
+
+        for (int bill : bills) {
+            if (bill == 5) { // 5美元
+                map.put(5, map.get(5) + 1);
+            } else if (bill == 10) { // 10美元
+                if (map.get(5) < 1) {
+                    return false;
+                }
+
+                map.put(5, map.get(5) - 1);
+                map.put(10, map.get(10) + 1);
+
+            } else { // 20美元
+                if (map.get(5) > 0 && map.get(10) > 0) {
+                    // 只存在最大20，所以优先找出10，留下较多5更方便找零
+                    map.put(20, map.get(20) + 1);
+                    map.put(10, map.get(10) - 1);
+                    map.put(5, map.get(5) - 1);
+
+                } else if (map.get(5) >= 3) {
+                    map.put(20, map.get(20) + 1);
+                    map.put(5, map.get(5) - 3);
+                } else {
+                    return false;
+                }
+            }
+
+        }
+        return true;
+
+    }
+}
diff --git a/Week_04/LevelOrder.java b/Week_04/LevelOrder.java
new file mode 100644
index 00000000..ea47633b
--- /dev/null
+++ b/Week_04/LevelOrder.java
@@ -0,0 +1,43 @@
+package Week_04;
+
+import Week_03.TreeNode;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+// 102. 二叉树的层序遍历
+public class LevelOrder {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+
+        if (root == null) {
+            return res;
+        }
+
+        Queue<TreeNode> qNodes = new LinkedList<>();
+        qNodes.add(root);
+
+        while (!qNodes.isEmpty()) {
+            int size = qNodes.size();
+            List<Integer> tempRes = new ArrayList<>();
+
+            for (int i = 0; i < size; i++) {
+                TreeNode node=qNodes.poll();
+                tempRes.add(node.val);
+
+                if(node.left!=null){
+                    qNodes.add(node.left);
+                }
+
+                if(node.right!=null){
+                    qNodes.add(node.right);
+                }
+            }
+            res.add(tempRes);
+        }
+
+        return res;
+    }
+}
diff --git a/Week_04/MySqrt.java b/Week_04/MySqrt.java
new file mode 100644
index 00000000..78abd349
--- /dev/null
+++ b/Week_04/MySqrt.java
@@ -0,0 +1,18 @@
+package Week_04;
+
+public class MySqrt {
+    public int mySqrt(int x) {
+        // 二分搜索
+        int l = 0, r = x, res = -1;
+        while (l <= r) {
+            int mid = l + (r - l) / 2;
+            if ((long)mid * mid <= x) {
+                res = mid;
+                l = mid + 1;
+            } else {
+                r = mid - 1;
+            }
+        }
+        return res;
+    }
+}
diff --git a/Week_04/README.md b/Week_04/README.md
index 50de3041..b5396904 100644
--- a/Week_04/README.md
+++ b/Week_04/README.md
@@ -1 +1,18 @@
-学习笔记
\ No newline at end of file
+##学习笔记
+
+本周的内容我总结一下就大学学的搜索算法中的几种：广度优先搜索、深度优先搜索、二分查找，而贪心算法其实可以理解为理想最优分配。
+
+
+   对我而言二分查找和贪心算法我是轻易接受的并且理解的，所以做这方便的题目时候只要理解题意了就能很快独立写出，但是很好笑的是，理解题意，
+因为很多题目很长而且读半天不知道啥意思，其中遇到一个题是扫雷游戏，我读半天没读懂，然后看了官方的还没看懂，然后看那些通俗的‘江湖人士’解析，
+还有理解错意的，哈哈，比如分发饼干，我以为是必须一对一符合，没想到还可以‘将就撑着的’，看了官方解析感觉自己好蠢；不过BFS和DFS相对来说不是很好想，
+而且即使想到解法和算法思想也和递归一样自己就容易晕乎，敲出的代码很多半路废掉，还是多多练习。
+
+
+
+对于二分查找的一个题目，【x的平方根】，我在解法使用的是二分查找（因为刚刚学习），但是在实际的开发过程中，肯定对于java而言我们通常使用内置
+的函数解出来了，就很难理解算法学习和实际应用的差距。所以之前学的算法结构是否能学习过程中和实际我们使用结合一下，虽然说算法思想统一的，但是其实应用
+我觉得还是有相应的捷径的，结合语言更巧妙一些，比如pyth内置的等等。
+
+
+
diff --git a/Week_06/LongestCommonSubsequence.java b/Week_06/LongestCommonSubsequence.java
new file mode 100644
index 00000000..e69aa309
--- /dev/null
+++ b/Week_06/LongestCommonSubsequence.java
@@ -0,0 +1,25 @@
+package Week_06;
+
+public class LongestCommonSubsequence {
+    public int longestCommonSubsequence(String text1, String text2) {
+        char[] s1 = text1.toCharArray();
+        char[] s2 = text2.toCharArray();
+
+        int l1 = s1.length + 1;
+        int l2 = s2.length + 1;
+
+        int[][] dp = new int[l1][l2];
+
+        for (int i = 1; i < l1; i++) {
+            for (int j = 1; j < l2; j++) {
+                if (s1[i - 1] == s2[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
+                }
+            }
+        }
+        return dp[l1 - 1][l2 - 1];
+
+    }
+}
diff --git a/Week_06/MinimumTotal.java b/Week_06/MinimumTotal.java
new file mode 100644
index 00000000..c5163974
--- /dev/null
+++ b/Week_06/MinimumTotal.java
@@ -0,0 +1,31 @@
+package Week_06;
+
+import java.util.List;
+
+public class MinimumTotal {
+    // 我擅长的动态规划 哈哈
+    /*public int minimumTotal(List<List<Integer>> triangle) {
+        int n = triangle.size();
+        int[] dp = new int[n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = 0; j <= i; j++) {
+                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
+            }
+        }
+        return dp[0];
+    }*/
+
+    // 我不擅长的递归，尝试老师讲解的方式再写出来
+    public int minimumTotal(List<List<Integer>> triangle) {
+        return minimumTotalRec(triangle, 0, 0);
+    }
+
+    private int minimumTotalRec(List<List<Integer>> triangle, int level, int index) {
+        if (level == triangle.size() - 1) {// 到底层返回对应坐标值即可
+            return triangle.get(level).get(index);
+        }
+
+        return Math.min(minimumTotalRec(triangle, level + 1, index), minimumTotalRec(triangle, level + 1, index + 1)) + triangle.get(level).get(index);
+    }
+}
diff --git a/Week_06/README.md b/Week_06/README.md
index 50de3041..743c095f 100644
--- a/Week_06/README.md
+++ b/Week_06/README.md
@@ -1 +1,10 @@
-学习笔记
\ No newline at end of file
+##学习笔记
+
+1、本周内容主旨：动态规划
+    动态规划：上完第一节课及做完部分题目我的个人理解是每次走当前分步的最‘捷径’，直至所有分步结合。就是说如果动态规划方案无优劣区分，及一个极端那就是前面我们学过的'分治'.
+            他比较适合大数据类型的’最小路径和‘题目解法,当前状态和前继最优匹配达成当前最优，整个问题拆分一个个当前节点这样处理，那么所有当前节点合并结果即是动态规划解。
+            
+    通过这周三天学习及做题情况发现，动态规划至关重要是发现递推公式（数学归纳法）
+            
+        动态规划我的解法第一步分析题意，定义出合适的状态（一般需要着重考虑到的是空间复杂度），第二步则找出dp方程，dp方程我发现可至上向下顺序滚动，
+        或者至下向上逆向循环（一般这样也可以递归），而dp方程也有数学归纳法的一点应用，总体根据题目具体分析，下一步则是据此求解处理就可以啦。
\ No newline at end of file
diff --git a/Week_06/Rob.java b/Week_06/Rob.java
new file mode 100644
index 00000000..1cd06a54
--- /dev/null
+++ b/Week_06/Rob.java
@@ -0,0 +1,27 @@
+package Week_06;
+
+// 打家劫舍（简单）
+public class Rob {
+    public int rob(int[] nums) {
+        int length = nums.length;
+        if (length == 0) {
+            return 0;
+        }
+
+        if (length == 1) {
+            return nums[0];
+        }
+
+        int resPre = nums[0];
+        int maxRes = Math.max(resPre, nums[1]);
+
+        for (int i = 2; i < length; i++) {
+            int temp = maxRes;
+            maxRes = Math.max(maxRes, resPre + nums[i]);
+            resPre = temp;
+        }
+
+        return maxRes;
+
+    }
+}
diff --git a/Week_06/Rob2.java b/Week_06/Rob2.java
new file mode 100644
index 00000000..b63e4a17
--- /dev/null
+++ b/Week_06/Rob2.java
@@ -0,0 +1,36 @@
+package Week_06;
+
+public class Rob2 {
+    public int rob(int[] nums) {
+        int length = nums.length;
+        if (length == 0) {
+            return 0;
+        }
+
+        int ignoreFirst = nums[nums.length - 1];
+        int ignoreLast = nums[0];
+        if (length <= 2) {
+            return Math.max(ignoreFirst, ignoreLast);
+        }
+
+        // 忽略第一个
+        int resPre = nums[1];
+        ignoreFirst = Math.max(resPre, nums[2]);
+        for (int i = 3; i < length; i++) {
+            int temp = ignoreFirst;
+            ignoreFirst = Math.max(ignoreFirst, resPre + nums[i]);
+            resPre = temp;
+        }
+
+        // 忽略最后一个
+        resPre = nums[0];
+        ignoreLast = Math.max(resPre, nums[1]);
+        for (int i = 2; i < length - 1; i++) {
+            int temp = ignoreLast;
+            ignoreLast = Math.max(ignoreLast, resPre + nums[i]);
+            resPre = temp;
+        }
+
+        return Math.max(ignoreFirst, ignoreLast);
+    }
+}
diff --git a/Week_07/LadderLength.java b/Week_07/LadderLength.java
new file mode 100644
index 00000000..3841c751
--- /dev/null
+++ b/Week_07/LadderLength.java
@@ -0,0 +1,96 @@
+package Week_07;
+
+import java.util.*;
+
+public class LadderLength {
+    // 一：bfs写法
+    public int ladderLengthOfBfs(String beginWord, String endWord, List<String> wordList) {
+        HashSet<String> wordSet = new HashSet<>(wordList);
+        if (wordSet.size() == 0 || !wordSet.contains(endWord)) {// 终结边界条件
+            return 0;
+        }
+
+        Queue<String> queue = new LinkedList<>();
+        queue.add(beginWord);
+        // 记录已经走的
+        Map<String, Integer> visitedPath = new HashMap<>();
+        visitedPath.put(beginWord, 1);
+
+        while (!queue.isEmpty()) {
+            String word = queue.poll();
+            int count = visitedPath.get(word);
+
+            for (int i = 0; i < word.length(); i++) {
+                char[] words = word.toCharArray();
+                for (char c = 'a'; c <= 'z'; c++) {
+                    words[i] = c;
+                    String newWord = String.valueOf(words);
+
+                    if (newWord.equals(endWord)) {
+                        return count + 1;
+                    } else if (wordSet.contains(newWord) && !visitedPath.containsKey(newWord)) {
+                        queue.add(newWord);
+                        visitedPath.put(newWord, count + 1);
+                    }
+
+                }
+            }
+        }
+
+        return 0;
+    }
+
+    // 二：双向bfs写法
+    public int ladderLengthOfBfs2(String beginWord, String endWord, List<String> wordList) {
+        HashSet<String> wordSet = new HashSet<>(wordList);
+        if (wordSet.size() == 0 || !wordSet.contains(endWord)) {// 终结边界条件
+            return 0;
+        }
+
+        Set<String> beginSet = new HashSet<>();
+        beginSet.add(beginWord);
+        Set<String> endSet = new HashSet<>();
+        endSet.add(endWord);
+
+        // 记录已经走的
+        Set<String> visited = new HashSet<>();
+
+        int step = 1;
+
+        while (!beginSet.isEmpty() && !endSet.isEmpty()) {
+            // 优先选择小的哈希表进行扩散，考虑到的情况更少
+            if (beginSet.size() > endSet.size()) {
+                Set<String> temp = beginSet;
+                beginSet = endSet;
+                endSet = temp;
+            }
+
+            Set<String> nextVisited = new HashSet<>();
+
+            for (String word : beginSet) {
+                for (int i = 0; i < word.length(); i++) {
+                    char[] words = word.toCharArray();
+                    for (char c = 'a'; c <= 'z'; c++) {
+                        words[i] = c;
+                        String newWord = String.valueOf(words);
+
+                        if (wordSet.contains(newWord)) {
+                            if (endSet.contains(newWord)) {
+                                return step + 1;
+                            } else if (!visited.contains(newWord)) {
+                                nextVisited.add(newWord);
+                                visited.add(newWord);
+                            }
+                        }
+
+                    }
+                }
+            }
+
+            beginSet = nextVisited;
+            step++;
+        }
+        return 0;
+
+    }
+}
diff --git a/Week_07/README.md b/Week_07/README.md
index 50de3041..7a11d053 100644
--- a/Week_07/README.md
+++ b/Week_07/README.md
@@ -1 +1,21 @@
-学习笔记
\ No newline at end of file
+#学习笔记
+
+###课后作业
+1、关于单词接龙题目我尝试bfs写法，整体还是很清晰，就是路途有点坎坷（使用toString转换了word的变换为新的单词时候，与字典库里面匹配使用 contains总会返回false，改为String.valueOf
+    就可以啦，猜测应该是没有重写toString方法具体没有深究，代码见class --LadderLength。
+
+2、老师提出的双向BFS代码模板，我尝试去写了一下，也不知道合理与否，代码见class --TwoDirecBfs。
+
+3、对于题目【二进制矩阵中的最短路径】的不同解法：课上老师讲了可以使用三个解法：dp解法；bfs解法；A*解法。但是我去实践时候发现我的BFS有列出dp方程，所以融为一个解法啦！
+    代码见class --ShortestPathBinaryMatrix；
+
+        (1).dp、bfs：
+        我的理解是grid所在可作为一个dp状态数组，以为不像之前的只会向下、右方向走，这个是八个方向，所以定义一个方向数组更
+        利用代码理解，简化代码，每走一个方向总会带来一个新的坐标的走向（只要在grid的界内---不超过坐标边界）
+        
+        (2).A*：我这边仿照了题解里面别人的A*解法
+            step1:定义查询时候的每个节点；(节点的各属性定义做题确实有点难想到)
+            step2:主函数终结条件
+            step3:类似bfs将边界内不是1的node走一下（智能选取：grid[newPosX][newPosY] > step + 1）
+            
+其实课上老师对A*解法解释我理解的有点混乱，最近工作影响下次找个充裕时间再重新学习理解一遍，加油^^。
\ No newline at end of file
diff --git a/Week_07/ShortestPathBinaryMatrix.java b/Week_07/ShortestPathBinaryMatrix.java
new file mode 100644
index 00000000..2e4e672a
--- /dev/null
+++ b/Week_07/ShortestPathBinaryMatrix.java
@@ -0,0 +1,113 @@
+package Week_07;
+
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class ShortestPathBinaryMatrix {
+    int N;// 用于A*解法
+
+    // 解法一：dp
+
+    // 解法二：bfs
+    public int solutionOfBfs(int[][] grid) {
+        int n = grid.length;// N*N
+        if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) {// 终结条件
+            return -1;
+        }
+
+        grid[0][0] = 1;// 将grid设为dp状态数组
+
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+
+        int[][] direc = new int[][]{{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, 0}, {1, -1}, {1, 1}};// 八个方向表示数组有利于简化代码
+        while (!queue.isEmpty()) {
+            int[] pos = queue.poll();
+
+            int posX = pos[0];
+            int posY = pos[1];
+            int len = grid[posX][posY];
+            // 一一列举不如重新声明一个八个方向表示数组
+            for (int i = 0; i < 8; i++) {
+                int newPosX = posX + direc[i][0];
+                int newPosY = posY + direc[i][1];
+                if (newPosX < n && newPosX > -1 && newPosY < n && newPosY > -1 && grid[newPosX][newPosY] == 0) {
+                    grid[newPosX][newPosY] = len + 1;
+                    queue.add(new int[]{newPosX, newPosY});
+                }
+            }
+
+        }
+
+        return grid[n - 1][n - 1] == 0 ? -1 : grid[n - 1][n - 1];// 未抵达右下角则表示不可抵达
+    }
+
+    // 解法三：A*
+    public int solutionOfA(int[][] grid) {
+        N = grid.length;// N*N
+        if (grid[0][0] == 1 || grid[N - 1][N - 1] == 1) {// 终结条件
+            return -1;
+        }
+        if (N == 1) {
+            return 1;
+        }
+
+        int[][] direc = new int[][]{{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, 0}, {1, -1}, {1, 1}};// 八个方向表示数组有利于简化代码
+
+        Node start = new Node(0, 0, grid[0][0] = 1);
+        Queue<Node> queue = new PriorityQueue<>();
+        queue.offer(start);
+
+        while (!queue.isEmpty()) {
+            Node node = queue.poll();
+            int step = grid[node.posX][node.posY];
+            for (int[] d : direc) {
+                int newPosX = node.posX + d[0];
+                int newPosY = node.posY + d[1];
+                if (newPosX == N - 1 && newPosY == N - 1) {// 倒数第二步走完再走一步就算结束了
+                    return step + 1;
+                }
+                if (newPosX < N && newPosX > -1 && newPosY < N && newPosY > -1 && (grid[newPosX][newPosY] == 0 || grid[newPosX][newPosY] > step + 1)) {
+                    Node next = new Node(newPosX, newPosY, grid[newPosX][newPosY] = step + 1);
+                    queue.offer(next);
+                }
+            }
+        }
+        return -1;
+    }
+
+    class Node implements Comparable<Node> {
+        int posX;
+        int posY;
+        int f;
+
+        // 坐标posX，posY
+        public Node(int posX, int posY, int step) {
+            this.posX = posX;
+            this.posY = posY;
+            int distance = Math.max(N - 1 - posX, N - 1 - posY);
+            this.f = distance + step;
+        }
+
+        // 重写 compareTo、equals和hashCode
+
+        @Override
+        public int compareTo(Node o) {
+            return this.f - o.f;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof Node)) return false;
+            Node node = (Node) o;
+            return posX == node.posX && posY == node.posY;
+        }
+
+        @Override
+        public int hashCode() {
+            return Integer.hashCode(posX * N + posY);
+        }
+    }
+}
diff --git a/Week_07/TwoDirecBfs.java b/Week_07/TwoDirecBfs.java
new file mode 100644
index 00000000..7efd49fa
--- /dev/null
+++ b/Week_07/TwoDirecBfs.java
@@ -0,0 +1,39 @@
+package Week_07;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+// 双向BFS代码模板（尝试）
+public class TwoDirecBfs {
+    public List<List<Integer>> levelOrder(String begin, String end, List<String> list) {
+        List<List<Integer>> res = new ArrayList<>();
+
+        Set<String> beginSet = new HashSet<>();
+        beginSet.add(begin);
+        Set<String> endSet = new HashSet<>();
+        endSet.add(end);
+
+        // 记录访问过
+        Set<String> visitedSet = new HashSet<>();
+
+        while (!beginSet.isEmpty() && !endSet.isEmpty()) {// 因为是双端所以俩个都判空
+            // 优先较短端遍历
+            if (beginSet.size() > endSet.size()) {
+                Set<String> temp = beginSet;
+                beginSet = endSet;
+                endSet = temp;
+            }
+
+            //...... 对beginSet操作
+            // 当俩端相遇则为终止返回
+            //...... 否则对beginSet重新赋值,若未访问则add to visitedSet,res  add
+        }
+
+        return res;
+    }
+}
+
+
+
diff --git a/Week_08/FindCircleNum.java b/Week_08/FindCircleNum.java
new file mode 100644
index 00000000..fb1a6be3
--- /dev/null
+++ b/Week_08/FindCircleNum.java
@@ -0,0 +1,49 @@
+package Week_08;
+
+public class FindCircleNum {
+    int[] pre;
+
+    public int findCircleNum(int[][] M) {
+        int N = M.length;
+        pre = new int[N];
+
+        for (int i = 0; i < N; i++) {
+            pre[i] = i;
+        }
+
+        int res = N;
+        for (int i = 0; i < N; i++) {
+            for (int j = i + 1; j < N; j++) {
+                if (M[i][j] == 1 && union(i, j)) {
+                    res--;
+                }
+            }
+        }
+        return res;
+    }
+
+    public int find(int x) {
+        int r = x;
+        while (pre[r] != r) {
+            r = pre[r];
+        }
+
+        int i = x, j;
+        while (pre[i] != r) {
+            j = pre[i];
+            pre[i] = r;
+            i = j;
+        }
+        return r;
+    }
+
+    public boolean union(int x, int y) {
+        int posX = find(x);
+        int posY = find(y);
+        if (posX == posY) {
+            return false;
+        }
+        pre[posX] = posY;
+        return true;
+    }
+}
diff --git a/Week_08/HammingWeight.java b/Week_08/HammingWeight.java
new file mode 100644
index 00000000..aac6b19f
--- /dev/null
+++ b/Week_08/HammingWeight.java
@@ -0,0 +1,13 @@
+package Week_08;
+
+// 位运算运用
+public class HammingWeight {
+    public int hammingWeight(int n) {
+        int res = 0;
+        while (n != 0) {
+            res++;
+            n &= n - 1;
+        }
+        return res;
+    }
+}
diff --git a/Week_08/IsAnagram.java b/Week_08/IsAnagram.java
new file mode 100644
index 00000000..e3cfb430
--- /dev/null
+++ b/Week_08/IsAnagram.java
@@ -0,0 +1,40 @@
+package Week_08;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// 排序
+public class IsAnagram {
+    public boolean isAnagram(String s, String t) {
+        // 适应如果输入字符串包含 unicode 字符
+        Map<Character, Integer> str1 = new HashMap();
+        Map<Character, Integer> str2 = new HashMap();
+        if (s.length() != t.length()) {
+            return false;
+        }
+        for (int i = 0; i < s.length(); i++) {
+            if (str1.get(s.charAt(i)) == null) {
+                str1.put(s.charAt(i), 1);
+            } else {
+                str1.put(s.charAt(i), str1.get(s.charAt(i)) + 1);
+            }
+        }
+
+        for (int j = 0; j < t.length(); j++) {
+            if (str2.get(t.charAt(j)) == null) {
+                str2.put(t.charAt(j), 1);
+            } else {
+                str2.put(t.charAt(j), str2.get(t.charAt(j)) + 1);
+            }
+        }
+
+        boolean res = true;
+        for (int k = 0; k < s.length(); k++) {
+            if (!(str1.get(s.charAt(k)) != null && str2.get(s.charAt(k)) != null
+                    && str1.get(s.charAt(k)).equals(str2.get(s.charAt(k))))) {
+                res = false;
+            }
+        }
+        return res;
+    }
+}
diff --git a/Week_08/LRUCache.java b/Week_08/LRUCache.java
new file mode 100644
index 00000000..1f27a7b3
--- /dev/null
+++ b/Week_08/LRUCache.java
@@ -0,0 +1,79 @@
+package Week_08;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LRUCache {
+    class LRUNode {
+        int key;
+        int value;
+        LRUNode prev;
+        LRUNode next;
+
+        public LRUNode() {
+        }
+
+        public LRUNode(int key, int value) {
+            key = key;
+            value = value;
+        }
+    }
+
+    private Map<Integer, LRUNode> cache = new HashMap<>();
+    private int size;// 大小
+    private int capacity;
+    private LRUNode head, tail;//  头尾节点
+
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.size = 0;
+        this.cache = new HashMap<>();
+        this.head = new LRUNode();
+        this.tail = new LRUNode();
+        head.next = tail;
+        tail.prev = head;
+    }
+
+    public int get(int key) {
+        // 查找并设置为最近使用
+        LRUNode node = cache.get(key);
+        if (node != null) {
+            moveToHead(node);
+            return node.value;
+        }
+        return -1;
+    }
+
+    public void put(int key, int value) {
+        // 先插队列中是否存在，存在则设置为最近使用，不存在则最近新增
+        LRUNode node = cache.get(key);
+        if (node != null) {
+            moveToHead(node);
+        } else {
+            node = new LRUNode(key, value);
+            addAtHead(node);
+        }
+    }
+
+    // 将节点删除
+    private void removeNode(LRUNode node) {
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+
+    }
+
+    // 将节点添加到最前面
+    private void addAtHead(LRUNode node) {
+        node.next = head.next;
+        node.prev = head;
+        head.next.prev = node;
+        head.next = node;
+    }
+
+    // 将节点移动到最前面
+    private void moveToHead(LRUNode node) {
+        removeNode(node);
+        addAtHead(node);
+    }
+
+}
diff --git a/Week_08/README.md b/Week_08/README.md
index 50de3041..dab49f40 100644
--- a/Week_08/README.md
+++ b/Week_08/README.md
@@ -1 +1,26 @@
-学习笔记
\ No newline at end of file
+###学习笔记
+
+1、位运算
+````
+1、如何从十进制转换为二进制？
+    工作中很少使用位运算，对于位运算还是停留在大学时候基础学习，当初转换十进制转换为二进制采用十进制数一直除2取模2的余数直至商为0逆向输出。
+在这里通常也暴力使用的就是一一枚举相应位数：课程里面内容方法叫做【降二次幂及减法混合运算】，当然二进制转十进制就简单了，就是相应位数数字和
+2的0,1,2...幂指数乘积和，有点【降二次幂及减法混合运算】方法的逆过程的意思。
+
+2、学习到n&=n1的使用技巧，清除最低位1。
+````
+
+2、LRU Cache 
+````
+1、实现机制：一个哈希表和一个双向链表，最近最少使用淘汰制
+2、具体见课后作业LRU Cache 缓存机制代码
+````
+
+3、排序
+````
+我们常用
+    冒泡排序：时间-空间O(n2)-O(1)
+    快排：时间-空间O(nlog2n)-O(nlog2n)
+    归并排序：时间-空间O(nlog2n)-O(n)
+    堆排序：时间-空间O(nlog2n)-O(1)
+````
\ No newline at end of file
diff --git a/Week_09/IsMatch.java b/Week_09/IsMatch.java
new file mode 100644
index 00000000..1c2c7c2c
--- /dev/null
+++ b/Week_09/IsMatch.java
@@ -0,0 +1,37 @@
+package Week_09;
+
+// 正则表达式匹配（Facebook、微软、字节跳动在半年内面试中考过）
+public class IsMatch {
+    public boolean isMatch(String s, String p) {
+        int sc = s.length();
+        int pc = p.length();
+
+        boolean[][] f = new boolean[sc + 1][pc + 1];
+        f[0][0] = true;
+        for (int i = 0; i <= sc; ++i) {
+            for (int j = 1; j <= pc; ++j) {
+                if (p.charAt(j - 1) == '*') {
+                    f[i][j] = f[i][j - 2];
+                    if (matches(s, p, i, j - 1)) {
+                        f[i][j] = f[i][j] || f[i - 1][j];
+                    }
+                } else {
+                    if (matches(s, p, i, j)) {
+                        f[i][j] = f[i - 1][j - 1];
+                    }
+                }
+            }
+        }
+        return f[sc][pc];
+    }
+
+    public boolean matches(String s, String p, int i, int j) {
+        if (i == 0) {
+            return false;
+        }
+        if (p.charAt(j - 1) == '.') {
+            return true;
+        }
+        return s.charAt(i - 1) == p.charAt(j - 1);
+    }
+}
diff --git a/Week_09/LengthOfLastWord.java b/Week_09/LengthOfLastWord.java
new file mode 100644
index 00000000..51dfce2c
--- /dev/null
+++ b/Week_09/LengthOfLastWord.java
@@ -0,0 +1,20 @@
+package Week_09;
+
+import java.util.Stack;
+
+// 最后一个单词的长度（苹果、谷歌、字节跳动在半年内面试中考过）
+public class LengthOfLastWord {
+    public int lengthOfLastWord(String s) {
+        Stack<Character> stack=new Stack<>();
+        if(s.length()<=0){
+            return 0;
+        }
+
+        int i=0;
+        while(s.charAt(i++)!=' '){
+            stack.push(s.charAt(i));
+        }
+
+        return i==0?0:s.length()-i;
+    }
+}
diff --git a/Week_09/README.md b/Week_09/README.md
index 50de3041..a142e366 100644
--- a/Week_09/README.md
+++ b/Week_09/README.md
@@ -1 +1,6 @@
-学习笔记
\ No newline at end of file
+###学习笔记
+最后一个礼拜的课程了，感觉时间过得好快，主要还是自己学习的很懵懂，以前会的算法还是解析掌握的很快，以前没见过或者不了解的算法现在还是不熟练，特别是那些很难懂的，很难去把握其中的规律，看来后续还是需要多
+多写多练多看，不过平时很难集中时间去独立做这些事情，不知道是自己接受学习的能力弱了还是学不进去还是说断断续续没有什么效果，还是蛮苦恼的，
+看见后面十周的课程是刷题路线，暂时没有太多刷题的感触，报了课程就是学习自己刷题嘛！ε=(´ο｀*)))唉，难受。。。。
+看着现在第九周了，班主还在给我们看第七周的反馈和五毒刷题，上周看的不就是这些反馈内容嘛，，真不怕我们审美疲劳，
+很多同学也没有之前的积极性刷题看视频了，感情淡了淡了。。。。
\ No newline at end of file
diff --git a/Week_09/ReverseStr.java b/Week_09/ReverseStr.java
new file mode 100644
index 00000000..56242ec6
--- /dev/null
+++ b/Week_09/ReverseStr.java
@@ -0,0 +1,17 @@
+package Week_09;
+
+// 反转字符串 II （亚马逊在半年内面试中考过）
+public class ReverseStr {
+    public String reverseStr(String s, int k) {
+        char[] a = s.toCharArray();
+        for (int start = 0; start < a.length; start += 2 * k) {
+            int i = start, j = Math.min(start + k - 1, a.length - 1);
+            while (i < j) {
+                char tmp = a[i];
+                a[i++] = a[j];
+                a[j--] = tmp;
+            }
+        }
+        return new String(a);
+    }
+}
diff --git a/Week_09/ToLowerCase.java b/Week_09/ToLowerCase.java
new file mode 100644
index 00000000..6300ee92
--- /dev/null
+++ b/Week_09/ToLowerCase.java
@@ -0,0 +1,14 @@
+package Week_09;
+
+// 转换成小写字母（谷歌在半年内面试中考过）
+public class ToLowerCase {
+    public String toLowerCase(String str) {
+        char[] c = str.toCharArray();
+        for (int i = 0; i < str.length(); i++) {
+            if (c[i] <= 'Z' && c[i] >= 'A') {
+                c[i] += 32;
+            }
+        }
+        return String.valueOf(c);
+    }
+}