├── .gitignore ├── .travis.yml ├── LICENSE ├── QA ├── performance testing v0.01 01.02.2017 │ ├── Screen Shot 2017-02-01 at 11.41.28 AM.png │ ├── Screen Shot 2017-02-01 at 11.42.08 AM.png │ └── medium.in exeption.txt └── performance testing v0.02 12.02.17 │ ├── Screen Shot 2017-02-12 at 9.47.03 PM MacBookPro.png │ ├── Screen Shot 2017-02-12 at 9.49.39 PM.png │ └── Screen Shot 2017-02-12 at 9.51.39 PM.png ├── README.md ├── documentation ├── TaskDescription.pdf └── logo.png ├── inputDataSets ├── big.in ├── example.in ├── medium.in └── small.in ├── outputDataSet └── example.txt ├── pom.xml ├── src ├── main │ ├── java │ │ └── com │ │ │ └── google │ │ │ └── hashcode │ │ │ ├── App.java │ │ │ ├── entity │ │ │ ├── Cell.java │ │ │ ├── Ingredient.java │ │ │ ├── Pizza.java │ │ │ ├── Slice.java │ │ │ ├── SliceInstruction.java │ │ │ └── Step.java │ │ │ └── utils │ │ │ ├── FilesPaths.java │ │ │ ├── IoUtils.java │ │ │ ├── Profiler.java │ │ │ ├── SlicingMethods.java │ │ │ └── StepsComparator.java │ └── resources │ │ └── logback.xml └── test │ ├── java │ └── com │ │ └── google │ │ └── hashcode │ │ ├── AppTest.java │ │ ├── entity │ │ ├── PizzaTest.java │ │ └── SliceTest.java │ │ └── utils │ │ ├── IoUtilsTest.java │ │ └── SlicingMethodsTest.java │ └── resources │ └── paragonOutputExample.txt ├── submitResultsViaSelenium └── zipSourceCode.sh /.gitignore: -------------------------------------------------------------------------------- 1 | #Java and Intellij & Eclipse specific 2 | .idea 3 | *.iml 4 | .project 5 | .classpath 6 | .project 7 | target 8 | #ignore the archived source code and output files 9 | /outputDataSet/* 10 | *.log 11 | *.zip 12 | /.classpath 13 | .settings/ 14 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: java 2 | jdk: 3 | - oraclejdk8 4 | script: mvn clean install -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 lyashenkogs 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /QA/performance testing v0.01 01.02.2017/Screen Shot 2017-02-01 at 11.41.28 AM.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/QA/performance testing v0.01 01.02.2017/Screen Shot 2017-02-01 at 11.41.28 AM.png -------------------------------------------------------------------------------- /QA/performance testing v0.01 01.02.2017/Screen Shot 2017-02-01 at 11.42.08 AM.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/QA/performance testing v0.01 01.02.2017/Screen Shot 2017-02-01 at 11.42.08 AM.png -------------------------------------------------------------------------------- /QA/performance testing v0.01 01.02.2017/medium.in exeption.txt: -------------------------------------------------------------------------------- 1 | 2017-02-01 11:40:30 [com.google.hashcode.App.main()] INFO com.google.hashcode.entity.Slice - cant perform step left ! 2 | [WARNING] 3 | java.lang.reflect.InvocationTargetException 4 | at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 5 | at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) 6 | at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 7 | at java.lang.reflect.Method.invoke(Method.java:498) 8 | at org.codehaus.mojo.exec.ExecJavaMojo$1.run(ExecJavaMojo.java:294) 9 | at java.lang.Thread.run(Thread.java:745) 10 | Caused by: java.lang.OutOfMemoryError: Java heap space 11 | at java.util.Arrays.copyOf(Arrays.java:3332) 12 | at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) 13 | at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) 14 | at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:421) 15 | at java.lang.StringBuilder.append(StringBuilder.java:136) 16 | at ch.qos.logback.core.pattern.FormattingConverter.write(FormattingConverter.java:39) 17 | at ch.qos.logback.core.pattern.PatternLayoutBase.writeLoopOnConverters(PatternLayoutBase.java:114) 18 | at ch.qos.logback.classic.PatternLayout.doLayout(PatternLayout.java:141) 19 | at ch.qos.logback.classic.PatternLayout.doLayout(PatternLayout.java:1) 20 | at ch.qos.logback.core.encoder.LayoutWrappingEncoder.doEncode(LayoutWrappingEncoder.java:130) 21 | at ch.qos.logback.core.OutputStreamAppender.writeOut(OutputStreamAppender.java:187) 22 | at ch.qos.logback.core.OutputStreamAppender.subAppend(OutputStreamAppender.java:212) 23 | at ch.qos.logback.core.OutputStreamAppender.append(OutputStreamAppender.java:100) 24 | at ch.qos.logback.core.UnsynchronizedAppenderBase.doAppend(UnsynchronizedAppenderBase.java:84) 25 | at ch.qos.logback.core.spi.AppenderAttachableImpl.appendLoopOnAppenders(AppenderAttachableImpl.java:48) 26 | at ch.qos.logback.classic.Logger.appendLoopOnAppenders(Logger.java:270) 27 | at ch.qos.logback.classic.Logger.callAppenders(Logger.java:257) 28 | at ch.qos.logback.classic.Logger.buildLoggingEventAndAppend(Logger.java:421) 29 | at ch.qos.logback.classic.Logger.filterAndLog_0_Or3Plus(Logger.java:383) 30 | at ch.qos.logback.classic.Logger.info(Logger.java:579) 31 | at com.google.hashcode.utils.SlicingMethods.getAvailableSteps(DFSMethods.java:40) 32 | at com.google.hashcode.App.slicePizza(App.java:38) 33 | at com.google.hashcode.App.main(App.java:26) 34 | ... 6 more 35 | [INFO] ------------------------------------------------------------------------ 36 | [INFO] BUILD FAILURE 37 | [INFO] ------------------------------------------------------------------------ 38 | [INFO] Total time: 17:15 min 39 | -------------------------------------------------------------------------------- /QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.47.03 PM MacBookPro.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.47.03 PM MacBookPro.png -------------------------------------------------------------------------------- /QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.49.39 PM.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.49.39 PM.png -------------------------------------------------------------------------------- /QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.51.39 PM.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/QA/performance testing v0.02 12.02.17/Screen Shot 2017-02-12 at 9.51.39 PM.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GoogleHashCode2017 2 | ![google hash code logo](./documentation/logo.png) 3 | hash tags: #hashcode #2017 #googleHashCode 4 | [![Join the chat at https://gitter.im/GoogleHashCode2017/Lobby](https://badges.gitter.im/GoogleHashCode2017/Lobby.svg)](https://gitter.im/GoogleHashCode2017/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) 5 | [![Build Status](https://travis-ci.org/LyashenkoGS/GoogleHashCode2017.svg?branch=master)](https://travis-ci.org/LyashenkoGS/GoogleHashCode2017) 6 | 7 | ##Pizza 8 | Practice problem for the Google HashCode 2017. 9 | 10 | ##Effectiveness's for v0.02 11 | Slicing of: example, small, medium slices took 10m 39 seconds on a MacBookPro 12 | Results: 13 | * example 6 14 | * small 30 15 | * medium 33037 16 | * big - too long to slicing. Was ran once 17 | from the commit and took about 20 hours.(a desktop PC with an Intel-I54670K) 18 | 19 | 20 | * original assignment - [Task.pdf](./documentation/TaskDescription.pdf) 21 | * [input data sets](./inputDataSets) 22 | 23 | ##Prerequisites 24 | 25 | * Java 1.8 26 | * maven 3 27 | 28 | ##Run 29 | To build and run the application execute: 30 | 31 | mvn clean install 32 | mvn exec:java -Dexec.mainClass="com.google.hashcode.App" 33 | 34 | ##Submit task automation 35 | Google provides an online mechanism to check the task results. It requires: 36 | * archived source code 37 | * at least one output file 38 | 39 | To zip the source code execute : 40 | 41 | ./zipSourceCode.sh 42 | 43 | 44 | ## Deprecated 45 | To automate interaction with online submission can be used [SeleniumIDE](https://addons.mozilla.org/en-US/firefox/addon/selenium-ide/) 46 | with a firefox browser. 47 | * login to the [submission page](https://hashcodejudge.withgoogle.com/#/rounds/6553823069863936/submissions/) 48 | * setup selenium test suite(submitResultsViaSelenium) according to yours file system 49 | * execute the test case and see scores on web. See the [video instruction on YouTube](https://www.youtube.com/watch?v=Wg7s3CtIeCs&feature=youtu.be) 50 | 51 | 52 | -------------------------------------------------------------------------------- /documentation/TaskDescription.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/documentation/TaskDescription.pdf -------------------------------------------------------------------------------- /documentation/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LyashenkoGS/GoogleHashCode2017/49297983677440fa24d5cf43d9cc60605cd85d92/documentation/logo.png -------------------------------------------------------------------------------- /inputDataSets/example.in: -------------------------------------------------------------------------------- 1 | 3 5 1 6 2 | TTTTT 3 | TMMMT 4 | TTTTT 5 | -------------------------------------------------------------------------------- /inputDataSets/medium.in: -------------------------------------------------------------------------------- 1 | 200 250 4 12 2 | TMMMTTTMMMMTMMTTMTTMTTMMTMMMTTTTTTMTTTTTTMMMMMMMTMMMMTTTMTMMTTTTTTMMMMMTTMTMTMMMTMTTMMTTMMMTTMMMTTTTMTTTMTMMMTTMTMTTMTTMTTTTMMMTTTMMTTMMMTTMMTMTMMTTMMTTMTMMMTMMMTMTTMMTMMTTMTTMMMMMTTTMMMTMMMMMMTMTTMTTTTTMMMMMMTMTMMTTTTMMTTTTMTTTMTMMTTMMTMTTMTTTMTMMTM 3 | MTMMTTMMMTTTMMTTTTTMTMTTMMMTMTTMTMMTTMMMMTTMTTMMMTTTTTMMMTTTTMMMTTMTMTTTTTMTMTTTTMTMTTMTMMTMMMMTTMTMTTTMTMTMMMTMTTMTMTMTTTTTMMTMMTTMMMMMMMTTTTMTMMMTTMMMMTTMMTTMTTTMMMMMTMMTMTMMTMTTMMMTTMMTMTTTTTTTTTTTTTMMMTTTTMMMMMTMMTTMMTMMMTTTTTMMMTTTMTTTMMMMMTMMMM 4 | TMMTMTMMMMMMTMTTMMMTTMTTTTTMMMMTTMTTMTTMTTMMMTTMTMTTMTTTMTTMMMTMTTMTTTTMTTMTTMMTMTTMTMMTMMTMMTMTTMMTMTMTTTMTMMTMTMTMTMTMMMMMTTMMMTTTMMMMMMTMTTTMTMTTMMMMTMTMMTMMTMTMTTTMTMMTTMTTTTMMTMMMMMTMMTTMTTTTTTMTTTTMMMTTMMTTTTMMMMMMMTTTTTTMMTMTTMTTMMMMTTMTMTTTMM 5 | MTMTTTTMMMTTTMTTMTMTTMMTTMTTMMTMTTMTTMTMTTTTMTMTTTMMTTMMTMTTMMMTTMTMTTTMTTTMMTTTTMTMTMTMMTMTTTTTMMTTTMMTTTTMMTTMTTMTMMMTTTMMTTMTMMMMMTTTMMMTTMMTMMMMTTTMTTMTTTMTMTMTTMTTTTTTTTTMMTTMMTMMTTTTTMTMTTMMTMTTTTTTMTMTMTTTTTMMMTTTMMTTMMMTMMMTMMTTTMTMMMMMTMMMTT 6 | MTTTMMMMTMTTTMTMMTMTMMTMMTMTMMMMTMMTMMMMTTTMTTMTTMTTTMTMMMTMTMMTMMTTMTTMTMTTTTTMMMMMMMMTMMTMTMMTTTTTMMMTTTTTTMTMTMMTMTTTTTTTTMTTMMTMMMTTMMTMTMMMMTTTMMMTTMTMMMTMMMTMTMMTMMMMMMMTMMTTTTMTMMTTTTTMMMMTTTTMTMTTMMMMMTMTTMTTTMMMTTTMTMTTMTTTTTTMMMMMMTMMMTMTTT 7 | TMTTTMTTMMMMMTMTTMMMMTMMMMMTTTMMTMTTTTMTMMTTMTTMMTTTTTTTTMMMMMTMMMMTMTTTMMTMMMTTTMMMTMMMTMTMTMTMTTMMMTTTTMMTTTMTTMTMTMMTMMMMMTMTMMTTTTMMTTMTMMMMTTTTMMMMMTMMTTMTMMMTMMTMTMTTTTMMTTMMTMTTTTMMTTMTMTTTMTMMMMMTTTTMTMMTTMMMTTTMTMMTTTTMTTTMMTMTMTMMTMTMTTMTMT 8 | TTMTTMMTMMTTTTMTTTMTMMTMMTMMMTMTMMTMTMMTTMMMTTTTTTTTMMMTMTMTTTMMTTTTTMTTMTMTTTMTMTMMMMMTMTTTMTTMMTTMTMTTTTTTMMTTTTMTMTMTMTTMMMMMMTMTTTTMMTMMMMMMMTMTMMTMTMTMMMTTTMMMMTTMTTMTTTMMTMTMTTMTTMTMTMTTMTTMMMMMTTMTMTTMMTTTMTMTTTTTTMMTTTTTTMTTTMTMTMMMMTMTTTTMMM 9 | MTTMMTMMTTTTTMMTMTMMMTMMTTMMTMTTTTMMTMMMMMTTTMTTMTTTMMTMTMTTMTTMMTMTTMTTTTTMTMTTMMTTTTMTMTMTTMTTMMMMMMMTTTTMTTTTMTMMMMMMTTMTMTTMMMMTTTMMTMTMMMTTMTMTTMMTTMMTMTMTTTMMTMMTMTTMTMMMTTMTTTMMMTTMTMMTTTTMTMTTMTTTTMMTTTMMMMTTTTMMMTTMTMTTMMMMTTMTMMMTMTMTTMTTMM 10 | MTMMMTTTTMMTTTTMMMMTMTMTTTTTTMMMTTTMTMMTTTMTTTMTMTMTTMTMMTMTTTMTMMTMMTMTTMMTMMMTTMMMMTMTTMTTTMMTMTMTTTMMTTTTMTMTMTMTTTMMMTMTMTMTTTTMMMMTTMMMMTTMTTTTTMMTMMMMMTTTMTMMTTMMMTTTMTMTTTTMMMMTMTMTMTTTTMMTMTTMTMMTMMTMTTMTTTMMTTTMMMMMMMMMTMMMMTMMMMMTTTTMMMMMMM 11 | MMMMMTTMMMTMTTMMTTTMMTMMTTMTMTMMTMMTTTTTTMTMMTTTMMTMTTTMTMMTTTTTMTTTMTTMTMTTMTTMMMTTTTMMTTTMMMMTMTMMMMMMMTMMTMTTTMTMMMTTMMMTMMTMTMTMTTMMTMMMMTTTTTTMTTTTMTMMMMMTTMMMMTTTTTMMMMMMMMTTTMTMTMMMTMMTMMTTTMMTTMTMTTTMTTMTMMTMTTMTTMTTMMMMMMMTMTMMTTTMTTTTTMTMTT 12 | TTMTMMMTTMTMTMTMMTTTMTMMTMMMMTMTTMMTMMTMMTMMTMTMTMTMTMMTMMMTMTTMMMMTMTTTMMMMTMMTMTTMTMTMTMTTMMTTMMTTMTMMMMTTTTTTTMTTTMMTTMMMTTTTTMTTMTTTTMMMMMTTTTMTMTTMMTMTTMTTTMTTTMMMMTMTTMTTMTTTTMMTMTTMTMMTTMMMMTMMMTTMTMTMMMMTTTTTMMMTMMMTTMTTTMMMTMTMMTMTMTMTMTTMMM 13 | MMTTTMTTTMTMMMTTMTTTTMTMMMTMTMTMMMTTTMMMMTTMMMMTTMMMMMTTTMTMMMMTTMTMMMTMMTMMTTMTMTTTMTMMTMMTTMMMMTTMMTMMMMTMTMMMTMMMMTTTTTTTMTMTTMMMMTTMTTTTTMTMTTMTMTTMTTMTTTTMTTTTMTTMMMMMMTMTMMTTTMMTTTTTTMTMMMMMTTTTMTTTTMTMMTMTTTMTTMTTTMTTMTMTMTMTTTMMMMMMMMTTTMMTMM 14 | TTTMMTMMTMMMTTTMTTMMTMTMMMMTTTMMMMTTMMMMTTMMMMMTMMMTMTMTMMMMMMMTTMMTTTTTTMTTMTMMTTTTTTTMTMTTTMMTMTTTMTTMMMMMMTTTTMMMTTTTTMMTMMMMTMMMTTMTMMTTTMTMMMTMTMTMTMMTMMTTTTTTMMTMTTMMTTMMTTMTTTMMMTMTTMMTTTMMMTTTTTMMMTTMTTTMMTMTTMMMMMTTMMTTTMTTMMMTTTMTTMMTTTTTTT 15 | TTTMMMMTTMTMTTTTTTTTMMMMTTMTMMMTMTMMMTMTTTMTTTMMMTMMMTTMMTTMTMTMMTMTMTMTTMTMMMMMMTMTTMTMMMTMTMMTTMTTMTMMTTMMTMTTMMTMTMTMTTTMTMMTMMTTMTTMTMTMTMMMMMMTMTMMMMTMMTTTTMMTTMMMTMMMMMMTMTMTMTTMMMTTMTMMTMMTTTTMTMTMMTTTMMMMTTTMTMMMMMTTTTTTTMTTMTMMTMTTTMTMTTTMMM 16 | TMMTMMMTMTMMMTMMTMMTTMTMTTMMMMTTMTTMTMMTTMTTMMMTTMTMTMMTTMMTTTTMTTMMTMTTMTTMTTMMTTTMTTTMTTMMMTTMTTTTTMTMMTTTTTTMMMMTTMTTMTTTMMTMTMMMTTMTMTMTTTTTMTTMTTMTTMTMMTTTTTTTTTTTTMMTMMTMMTMTMMTMMMMTTTMTMTMMMMTMTMMMMMMTTTTTMTMTTTTTMTTMTMTTMTMMTMTTMTTMMTTTMMTTTT 17 | TTTMMMMMTTTMMMTMMTTTTTTTMTMTMMTMMTMTMMTTTMTTTTMTTTMMTTTMTTMMTTMMTMMTTTTTMTMMMTMMMTMTTMMTMTTMMMMMMTMTMTTMMMTMTTTMTMTMMMTMTMTTTTTMTMMTTMMTMTTTTTMTMMTTTTMMMMMMMMTMMMMTMTTTTMTMTMTTTMTTMTMMTTMMMTMMMTMMTTMMMMTMMTMTMTMMMTTTMTTMMMTTMTTTTMTMTMMTMMMMTTMMMMTMTT 18 | MMMTTTTTTMMTMTTMTTTTMMMMTMTMMTTTMMTTMMMTMTMMMTTMTMMTMMMTTTTTMTMMMMTTTMTMMMTMMMMMMTTTTTTTTMMTTMMTTMMMMMMTTMMTTTMMMTTMTMTMTTMMMMMTTTTTTTTTTTTMMTMMMTTTMMTTMTMMTTMTMMTMTTTMMTTMMMTMMTTTTTTMMTMTTTMTTMMTMTMTTMTMTTMTMMTMTMTMMTMMMTMTMMMTMMMMMMMTMTMMTTTTTMTTMT 19 | MTMTMMMTTMMMTTMTTMTMTMTTMMTMMTMTTTMMMMMMTMMTMTTMMMTTTTMMMMTTMMTMMMTTMMMTMTMTTMMTTMMTTMTTTTTTMMTTMMMMMTTMMMTTMMMMMMMMTMMTMMMMMTTTTMTTMTMMTTMTMMMTMMMTTMMMMMTTMTMTTMTMMMTTTMTMTMTMMTTTMTMMTMTTMTMTTMMTMMMMTMMTMTMMMMTTTTMTTTMMTTTTMMTMMTMMMTMMMTMTTTMMMMMMTM 20 | MMTTMTTTMTMTTMTMTMTMTMMMTTTTTMMTMTMMTMTMTTMMTTMMMMTTMTTMTMTMTMMTMMTTMMMMMTMMMTMMTMTTTMTTMTMMTTTTTMMMTMTTMTTTMMMMMTMTMMTTTTMTTTTTMTTMMTMTMTTMTTMTMMMTMTMMTMMTTMMMMMTMMMTTMMTMTMTTMMTMTMTMMMTMMTTTMMMTMMTTMMTTTTMTMMMMTMTMMTMTMTTMMMTTMTMMMTTTMTTMMTMMTTMTMT 21 | MMTMMMMMTMTTTTTTTMTMMTTMMTTTMMMTTMTMMTTTMTTMTTMTTMTTMMTTTTMMMTTTMTMMTTMTMMTMTMTTTMTMMMMTMMMTTTMTTTMMMMMMTMMTTTTTTTMTMTTMTTTTMMMMTMMTMTMTMTMTTTMMMMTTMMMTTTTMMMMTMTTTMMTTTTMTMTMMTMTMMMTMMTTMTMTMMMTMTTTTMMTMTTTMTMMMTTTTTMMTTMMMMMMTMMTMTTTTMTTTMTTTMTMTTM 22 | MTTTMMTTTMMTMTTTMMTTMMMTMTMMTMTTMMMMTTTTMTTTMTMTTMTMTMTTTMTMMTTTTMTTTTMMMMMMTMMMTTTMMMTMTTTTMTTTTMTMTTMTTTMMMTTMTMTMMMMMMMMMTTMMMMTMMMTMMMMTMMMMTTTTTMTTTTTTMMTTMMTTMMMTTTMTTTTMMMMMMTTMMTTMTTTMMTTTMMTTTMTTMTMTTMTMTTMTMMTTMMTMTTTTMMMTMTMTMTTMTMTMMMTMMM 23 | MTMTTMTTMTMMMMTTMMMTTMTTMMMTMMTMTMMTTMMTTMMMTTTMTMTMTTTMMTMTTTTMMTMMTTMTTMMMTMTMTMTTMMTTTTMMMMTTTMMTTMMMTMMMTMMTMTMTTMMMTMMTTMMTMTMTTMMMMTTTMTMMTMTMTTTMTTTMTTMMMTMTTTTMMTMTTTMMMMMMMMMTTTTTTMTMTTTTTTMMTTTMMTTMMMTMMMTMMMTTMMMTMTTTMMTMMTMTTTMTTTTTMMTTTT 24 | MTTMTTMTMTTMTTMMTTMMMMTTTMMTTMMTTMMTMTTMTMMTMMTTMTTMTTMMTMTMTMMMMTMMTTMMTMTMTTTMTTMTTTTMMMMTTMTMMTTTMMMMMTTMTTTMTTMTTMMMTTTMMMMTMMTTMTTMMTTTMMTMTMMMTTMTTMTMMTTTMMTMTMMTTMMMMTMTMMMTTTMMTMMTMMMTTTTTMTTMTMTTTMTTMMTTTMTMTMMTMTMTTMMTMTTMMTMMMTTTMMTTMTMMTT 25 | MTMMMMTTTTMTTMTTTMMTMMTMTMTMMMTTTMTMMMTMMMMTMTTTMTTTTTMTMMTMTMMTMTTTMTTMMMTMMTMTTMMTMTTTMMMTMMMTTMMMMTTMTTTTMMMMMMMTMMMMTMMTMMMMMMTTMTMMTTTMTTMTTTMTMMTMMMTTMTMMTMTMTMMTTTMMTMMMMTTMTMTTMTTMTMTMMMTTMTTMMTMTTTMMMTMTTMTMMMMTTMTTMMTMMMTMTTTTTMTMTTTMMMTMMM 26 | MTMMTTTTMMTTTTTMTTMTTMTMMMTMMMMTTTTTTTMMMTTMMMTTTTMTMTMTMMMMMTTMTTMMTTMMMMTTTTMTMMMTTTMMTTMTMTMMMMTTTMMTTMTMTMMMMMMTMMMTTTMMMMTMTMTMTMMTMTMTMMMTMMMTMTTMTMTTMTTMTTMTTMMTMMMTMMMTMMMMTTMTMTMMTTTMTMMMTTTMMTMMMMMTTMTMMTMMTTTTMTTMMTTMTMMMTMTMTMMMMMTMTTTMMM 27 | MMMTTTMTTTMMTTMTMTTMTMMMTTTTMMTMMTMTMMMTMMTTMTMTMMTMTMMTTTMTTMTTTTMTTTMMMTMMMTMMMTTMTMMMMTMTMTMMMMTTMTTMMTMTTTMMTMTTMMTTTTTTMTMMTMTMTMMMMTMMTMMTMMTTTTMTTMTTTTTTTMTMTMTMTTMTMTMMTMMTTTTTMMTTTMMTTTTTTTMTTTMMMTTTMMTMMMTTTTTTTMMTMTTTMMMTTTMTTTTTTMTMMMMMMT 28 | MTMTMTMTMTTMMMTTTMTMMMMMTTMTMMMMTTTTTMMMMMTTTTTTMMTMMMTTTMTTTMMTMMMMTTTTMTTTMMTMTTMTTTMMMMMTMTTMMTMMTTMMTMMTMTTTTTTMMTTTMTTMTTTMMTTMTTMTTTMTTTTMMTMMMTMMMTTMTMTMTTMMMTMTMTTTMTMTMTTTMMMMMMTMMTTMMTMMMTTTMMMMMMMTTMMMTMTMMMMTMTMTTMTTMMTTTMTMMMMTTTTMTTMTTM 29 | MMMMMTTMTTMTTMMMMMMMTTMTTMTTMMTTTTTTTMMMTTTTMTTMMMTMMMTMTMMMMMMTMTTTMMTTTTTTTTTMTTMMTMMTMMMMTMMTTMMMTMMMMMMTMMTTTTTMMTMMTTTTMMTTTMMMTTMTMMTMMTMTMTMMTMTMTMMTMMMTTMMMMTTMMTMMTTTTMTTTTMMTTMTTMMTTTMMTTTTTTMMMMMTTMTMMTTTMMTTMTTTMMMTMMTMMTMTTTTTTTTMMTTTTTM 30 | MTTMMTTMMTMMMTTTMMMMMTMTTMMTMTTMMMTTMTTMMTMMMTMMTMTMTTMTMMMTMTTTTMTTTTMMMTMTTMMMTTTTTTTTTTTMTMTTMTMMTMTMMTMTTMTTMMTMMMTMMMMMMMMMMMTMMMMMMMMTMMTTMTMMMMMMMMTMTTMTTMMMTMTMTTTMTMMMTMTMTMTTMMTTTMTTMMMMTMMTTMTMMTMMTMMTMTTMMTTMTTTTTTMMTTTMTTMMTTMMTMMMMTMMTM 31 | TMMMMTTMMTMTTMTTTTTMMMMTMTTMTTTTMTMTTTMTMTMTMMTTMMMMMMMTMTTMMMMMTMMTTTMMMMMMMTTTTTTTMMMMTMMTMMTMTTMMMTMTTMMTTTMTTMMMMTMTMTTMMTMMTMMMTTMTTMMMMMTTMTTTMMMTTMTTTTMTTTMMMTMMMMMTMTTMTMMTMMMMMMTTMMMMTTMTMMTTMTMTMTMMTTTTTTTMMTTMMMTTMMTMTTMMTTTTTMMMTMTTTTMMMM 32 | TTMMMTTMMMTMMTTTMTMMMMTMTMMMTMMMMTMMTTTTTMMMMMMMTTMTTTTTTMMTTMMTTMTTMMMTMTTTTMTMMTTMMTMTMTMTTMMTMTTMMTTMTMTTTTTMMTMMTMTMMTMTMMMTMMTMMTMTMMMTMMTTMMMTMTTTTTMMMMMTTTTMTTMTMTTMTTMMTTMTMTMTMTMTMTTTMMTTTMMTMMMTMMTTMTTMMMTMTMMTMTMTTMMMMTMMTTMMMMTMTTTTTTMMMM 33 | TTTMMMMTMMTMTTTMMMMMTMMTTMMMMMMMMMTTMMMMTTMTTTMTTTTTTTMTTMTMMTTMTMTTMTTMTTTMMMMMMTTTTMMTTTTTMMTMMTTTMTTTMMMMTMMTMMMTTTMMTMTMMMMMTMTMTMMMTTTTTMMTTTTMTMMMMTMMMMMMTTMTTTMMTTMMTMTMMMTTTMTTTTTMMTTTTTMMTMTTTMTTTMTTTMMTMMTTMMMTTMTTMMTTMMTTMMTTTTMMTMMTMTMMMT 34 | MTMTTTMMMMMTMTMMTMTTMTMTTTTMMMMTTTTTMMMMMMTTTMTTMTTMTTMMMTTTMMMTMMTMTMMTTTTTTMMMTTTTMTMTTTMMMTMMTTMMTMTTTMMMTMMTTMTTTTTTMTTMTTTTMMMMTTTMMTTTMMTTTMMTTTTMMTMMTTMMTMTTTTMTMTTMTMTMTMTMTTTMTMMMTTTTTMTTTMTMTMTMMTTTTTMMMTMMMTTMTTTTMTMTTMTMMTTTTTMMMMTTTMTTTT 35 | TTMTMMMMTTMTTMTTMMTMTMMTTMTMTTTMTTTTMTTTMTMTTMMMMTTMTTMTMTMMTTTTMTTTTMTMMTMMMTTTMMMTMMMTMMMMTTMTTTMMTTTMMTMMTMMMTMTMMMTMMMTMMTMTMTMTTTTTTMTMMTTTTTMMMTMMMTMTTTMTTMTTTMMTTTMTTMMMMTTMMTTMTTMTTMTTTTMTTTTTTMTTTTTTTTTTTMMTTTMMMMTMTTMMMMTTMMTTTMMTMMTMMMTMMM 36 | MMTMMMMTMMMMMTMMTMMMMTMMMMTTMMMTMMTTTMTTTTTMMMMMTTMTMTTMMMTMMTMTTTMTMTTTTMTTTMMMTTMTMMMMTMMMTTMMMMMMMMMTMMTMMTMMMMTTMTMTTMTMMTMTMTTTMTTMTMTTMTMMTMTTTTTMTTMMTTMTTMMTTTTMTTTMTMTMMMMMTTTMTTMMTTMMMMMTTMTTMTTMMTMMTTTMTMMTTMTMTTTTTMTMTTTTTMMTTTMMTMTMMMTMMT 37 | TMMMMTMMMTTMTTTTMMTTTMMMMTMTTMTMTMMTMMMMMTTMTMMTTMTMMMTMTMTTMMMMTMTMTTTTMTTTMTMTMMTTTTTMMTMTMMTTMMTTMMTMMMMTMTMTTMMMTTTMTMTTTTMMTMTTTMMTTTMMTTTMTMMTTMMTMTTMTTMMMMTTMMTTTMMMTTMMTMTTMTTTTTTTTMMTTTMMTMMTTTTMMTTMTTMMMTTMMTMTTMTTMMTTTTMMTMMMMMTTTTMMTMTMTM 38 | TTMMMTMTTTTTMTTTTTMTMMTMTTMMTMMTMTMTTTTMMMTMMMMMTMMMTTMMTMTMTTMMTTMTTMTTTTTMTMTMMMMMMMMTTMMTTTTMMMTMTMMMMMTMMTMTMMMMTTTMTMMMMTTTTMTMTMTMMMMTMTMTMMTTMTTMTTTTMMMMTMTMTMMTMMTMMTMTMMMTTTMTMTTTTTMMMTTTMMMMTTMTTMMTTTTTMTTMMTTMMTMMMMMMMMMTTMTTTMMMMTMTTMMTMM 39 | MMTTTMTTMTMTTTTMTTMTTMMTTTTTTMTTMMMTTMTTMMTMMTMMTMTMTTTTMTTTTMMTMMTMMMTMMMMTMTMMTTMMMTTMTTMTTMTTMMMTMTMMMMTTMMTMTMTMTMMMTTMMTTMTTMTMTTTTMTMTMMMTTMTTTMMMMTMMTMTMMMMMTTTMTTMMTTTMTMTMMMTMTMMMMMTMTTTTMTMTTMTMMTTMTMTMTMTMTTMMTMMMMMTMMMTMTTTTMTMTMMTTMMMMMT 40 | TTTMMMTTTTMTMMMMTTTTMMTMMMTMMMTTTTMMMTTMMTTTTMMMMTTMTTMTMMTMMTMMMTTMMMTTMMMTTMMTTTMMMMMMMTTMMTTMMTMMTTMTTMMTMMMMTMMMMMMMTTTTTMMMTTTTTMMMMTMTTMMMMMTTTTTTMTTMTTTMMMTTMTMTTTTTTMTTMTTMMTMMTMTMMTTMTMTMMTTTMMTMMMTMMMTMMMMTTTMMMTMTMMMMTTMTMMMMTTMTTMMTMMTTTM 41 | TMMMMTTMMMMMTTMTTMMTMTTMTMMMTTMMMTTMMMMMMTTTMMMTMMTTMMTMMTMMTMMMMTMMMMTTTTTTTTMTMTTMTTMMTTMTMTMMMMMTMMTTTMTTMTMTMTTMTMMTMTMTTMTMMTTMMTTTTTMMTMTMMTMMMTMTTTTMTMTTMMTMTMTTTTMTMTTMMMMMMTTMTTTMTTMMTMMTTTMTTMMTTMMMMMMTMMMTMMTTMTMTTMTTTTMMTMMTMMMMMTMTTTTTMM 42 | TTTTMTTTTMTTMMMTTMMTTMMTTTTTTTMTTMMMMTTMMMMMTMTTTTTMTTMMMMMTMMTMMMMTMTMTMTTTMTTMTTMTTTMMMTMTMMTMTTTMMMMMMTMMTMTMMMMMMMTMMTTTTTTTMTMMTTMMMTTTTMTTTMMTTMMTTMMTMMTMTTTTMTMMMMMMTMTMMTMTMMMTMTMTMTMMMTTTMTMTMMTTMTTMMMTMMMTMTTMMTMMTMTTMMTTMTTTTTTMMTMTMTMMTMT 43 | TTMTTTMMTMMTMMMTMMTMMTTMMTTTTMMTTMTTMTMMMMMMTTTTTTMMMTTTMMMTTMTTTMMTTMTTTTTMTMMMMTMMMMTTTMTTMTMMTTTMMMTTTTMMMMMTTTMTTTMMMMMTMTTTTTMMTTMTTTTMTMMTTTTTMMTTMMMTTTMMMTTMTMTTTTMTMTTMTTTMTMMMTTMMTTMMTTTTMMTMMMMMTTMTMMMMMTMMMMMTTMTMTMMMMTTTMTMMMMTTTMTMMMMMTM 44 | TMTMMTMMTTTMTMTTMTTTTTTMMMTTMTTMMTTMMTMMMMMMTMMMTTMTMMMTTMMTTMTTMTMMTMMMMTMMMTTMTTMMMMMTMMTMMMTTMTTMMTMMMTMTTMTMMMMMTMMTTTTMTMTTTTMMTMTMTMMTMMMTMTTMMMMTTTTMTMTMTTTMMTTTTMTTMMMMTMMTTMMMMMTMTTMTTTMTMMTTMMTMMMTTTMTTMTTTMMTTMTMMTMTMTMTMTMTMMMMTTTTTTTTTTM 45 | TTTMMMMMTTMTTTMMTMMTMMMMMTTMMMMTMTTTTTTTMMTTTMMTMTTMMTMTMMTTMTMTTMTTTTTTMTTMTTTMMMMTMTTMMMMTTTMMMTMTTTTMMMTMTTTMTMMTMMMMMTMMTMMTMTMTTMTMTMTMTTMTTTTMTMMMMTMMTMMTMTTTMMMTMTMMMMTMTMMTMMMTMTTTTTMTTMMTTTTTMTTMMTTMTTMMMMTMMMMMMTTMMMMTTTTTTTMMTMTTTTMMMMTTMT 46 | TMMTTTTTMMMMMTMMMTMTMMTTMMTMTTMMTMMMTMTMMTTTMMMMTMTTTMTMMTTMTTMMMMMMTTMMMTTMMMMTTMMTMMMTTMMTTMTTTTMMMMTTTMTMTTMMTMTTTMMMMMTTMTMMTMTTMTTTTMMMMMMTTMMMMMMTTTTMMTMMMMMTMTTMMTTTTMMTMMMTMTMMMTMTTMMTMTTMMTTMMTTMMTMTMMMTTTMTMTMMTMTMMTMMMTMTTMTTMTTTTTMMTMMMTT 47 | TTTTMMTMTTMMTMMMTTTTTMTMTMMTMMTTTTMMMTMTTTMMTMMTTMTTTMMMMTTMMMMTTMMTMTMMMMMTTTTTMMMMMMTMTMMMTTMMMTMMMTMTTTMTMMMTMMTMMTMTMTMMMMTTTMMTTTTTTMMTMMMMTTTTTMTMMTTTMTMMTTMMTMTTMMTTMTTMTMMMMTMMTTTMTTMTTMMTTMMTTTMTMMTMMTTMMTMMMMMTMTTMTTMTMTMMTTMMTTTTMTTTTTMTMT 48 | MMMMTMMMMTMTMTTTMTMTMMMTMTMMTTMMMMTMTMTTTMMTMMTMMTMMTMTMMMMMMMTTMTMMTMTTMTTMTMMMMTTMTMMMMMMTTTMMMTTTMTTTTTTTTTMTTTTTMMMTTTMTMTTTMMTMTMMMMMTMMTTTMTTMTMMMTTTTTMMMMMMMTMMMTMTMMTTMMMMMTMMTTMTMMTTMMTTMMMMMTMTMTTMTMTMTMMTMTMMMTMMTTMTTTMMMMTTTTMTMMMMTTMMTMT 49 | MTTMMTTMMTMTMMTTTMTTMMTMTMTTMTTMMMTMMMMTMMMTMTTTTTTMMTTTMTMMMMMMTMMTMMTTTMMTTMMTTMTMTMTTTMTMMTTMMMMTMTMMTMTTMTTMTMMTMTMTTTMMTTMMMTTTTMTTTMTTMTTTMMTMMTMTTTMMMTTTTMTTMMTMTMTMTTMMTTMMMMTMTMMTMMTTMMTMTMMTTTTTMMTTTMTTTTMTTMTMMTMTTMMTMMTTMTTTTMTTMTTTTTMTMT 50 | TMMTMTTTTTTTTTMTMTMTTTTMTMTMMMMTMTMTTMMMTTTMTTTMTMTTMMMMMTMTTTTMMTTTTTTMTMMTTMMTTMTMTTTMTMTMMTTMMTTMMTMMMMTTMTTMTTTTTTTTTMMTTMMTMTTMTMTTTMMTTTTTTTMTMTMMTMTTMMTMTMTTTTTMTTTMMTTMTTTMTTMMTTMMTTTTTMTTMMTMMMTTTMMTMMMMTTMMMMTTMTTMTTMMMTTMMMTTTTMTMMMTTTTTTT 51 | MMTMMTTTTMMMMTTMTTTTTTMMMTMMMTMMMTTTTTTMTTMTTTMTMMMMTMMMMMTTMTTTTTMTMTTTTTTMMMTMTTTTMMTTMTTTMMMTMTMTTMMTTTTTMTMMMTTMTTTMTTMTMMMTTMTTMTMTMTMTMMMTMTTMTMTMMTTTTMMTMMMTMTTMTMMTMTTMMMTTMTTMMTMMMMMMTMTMMTTMTMTMTTMTMMMMMTTTMMTTMTTTTMTMTTTMTMTMTMMTMTTTMMTMMT 52 | TMMTMTMMTMMMMMTMMMMTTTTTTMTMMMTMTTTMMTMMTMMTMTMTTMMTMMMTMTMTTTTTTMMTMTMTMMMTMTTTMTMMTTMMTTMTMTTTTTMMTMMMMMTTTTMTTTTTTTMMMMMTTTTMTTMTTMTMMTMMTTMTMMMMMMTTMMTMTTTMMTMMTTMTTTMMTTTMMTTMTMTMTTMMMMTTTMMTTTMTTMTTMMTMTMMTMTMMMMTMMTTMMTTMMMMMMTTTTMMMTMTTTTMMTT 53 | TTTMTMMMTTTMTTMTMTTMTTMMTMTMMTMTMTMMMMTTTMTMMTMMMMTTMMTTMTMMMMMMMMTTMMTMTMTMTMMMMMTTMMMMTTMMMMTTTMTMMMMMMTMTTTTTMMMMTTMTMTMMMTMTTMMTTTMMTTMMTMMTMTMMMMTTTTTTTMTTMTMTMTMMMMTTMMTMTTTTMMMTMMMTMTTMMTTTTMMTMMTTTMTMMMMTTMTTMMTMTTTMMTTMMTMMTTMTMMMMMTTMTTMTMT 54 | TTMTMTMTTMTMMTTTMTTMMTMMMMMMTTTMMMTTTMTTTTTTMMTTTMTMMMMMTTMMTTMTTTTMMMMMMMMMTTMMTTTMMTMMMMMTTTMTTTTTMMTMTTMMTMTMMMMMMMMTTTTTTMMTTMTTTMTTTTTTTMMMTTMTTTMTMTMTTMTTTMTMMMTTMTTTMTTMMTTTTTTTMTTTTTTMTTTTTMMTMTTTMMMTMTMTTMMTTMMMTMMTTMTMMMMTMMTMMMTMMMMTMTMMMM 55 | MTTMTMTTMTMMMMTMTMTTTMTMTMMTTMMMMTTTMTMTMTTMTTMTMMMMMMTMMMTTTTMMMTTMMTTMMTTTMMTMTTTMMMTMMMTMMTTTMMTTMTMMMTMMTMMMTMMTMTTMTMTTTMMMMMTTTMMTTMTTTMTTMMMMMTTMTTMTTTMTTTTTMTMTMMMMTMTMMMTTMTMMTTMTTTTTTTMMMMTTMMMMTMTTTMMTTMMMTTTMTMTMTMTTMTTTMTTMTMMMMTTMTMTTTM 56 | MTTMTTMTMMMTTMMMMMTMTMTMTTTMTTMMTMMMTTMTTMTMMTTMTTMTTMMMTMMMMMMMMTTMMMMTMTMTMTMTMTTMMTTTMTTTMTMMMMMMTMMTMTMTMMMMTTMMMMTMMTTTTTTMTMTMTMMTMMTMTMMTMMMTTTTMTTTMTMTMMTMMMTTMTMMTTTMTMMMMMTTTMMMMMTTMMMMTTMTMTTTMTTTTTMTMTMTMMTMMMMMMMTMTTTTMMMMMMMMTMMMTTTMMMM 57 | TMTMTMTTMMMTMTMTMMMTMMTMTMMTMMMTMTTTMTTMTMTMMTMMMMMTMTMTMTMTMMTMMMMTTMMMTTTTTMTTTMTTTTTTTTMTMMTMTTMTTMTTTMTMMMTMTMMMMMTMMTMTMMMTMMTMTTMTMTMMMMMMTMTMMTTTTMMMTMTTMTMTMMTTTTMMMTMTTTTMMTMTTMTTMTTTTMTMTMTMTMMMMMMTMMMMMTTTTMMTTTTTMMMMMMMTMMMTMTMMMTMMTTTMTT 58 | MMTMTMTTTTMTTTTMMMTTMMTTTTTTTTMTTMTTTTMMMTTMTTTTMMTMMTMMTMMTMTMMMTTMTTMTTTTMTMTMTMMMTTMTMTMTTMMTMTTMTMMMTMTTMTTTMMTTTTMMMTTMMTMMTMMMTTTTTTTMMTTMTTMMMTMTTMMTTTMTMTTMTMTMMMMMTTTMTTTMTTTMMMTTMTMTMMTMTMMTMMMMMMMTMMMMTMTTTTTMMMMTMMTMMTTTTTTTTMTMTTMTMTMMMT 59 | TMMMMTMTTTMMTTTTMMTMTTTTMTMTTMTMMTMTMMTTMMTMMTMTMMMMMTMTMMTTTTMMTTTTTMMMMTTTMMTTMMTMMTTTMTMMMMTTTTMMMMMTMTMMMMMTTTMMMMTTMTTTMMMMMTTMMMTMTMMTTTTTTTTMTMTTTMMMMTMTTTTTTMMTTMTMTTMMTTMTMTMMTMTTMMTMMMTMTTTTMTTMMTTTMMMMTTTMTTTMTMTMTTTTMTTTTMTMMMTMMMMTMTTMTT 60 | TMTTMMMMMTMMMMMMTMTTTTTTTTMMTTTMMMTMMTTTTMMTMMTTMMTTTTMTTTMMTTMMTTMTMTMMTTMMTMTTMMMMTMTMTTMMMMTMTMMTTTMMTMTTMTTTTTMTTTMMMTMTTMTTMTMTMMMMMTMMMMMMTTMTMMMMMTMTTMMTTMMMTTTTMTTTTMMMMMMTMTTMTMTMTMTTMTTMMMMTTMMTTTMMMMTMTTMMTMTTMTMMTTTMMMTMTMTTMMMMMMTTTTTTMT 61 | TMTMTMTMTMTMTMTMTMTMMTMMMMMTTTTTTMTTMMMMMTTTTTTTTMMMTMTTTMMTTMMTMMTTMMMTMMTMTMMTMMTMMMMMTTMTMMMTTTMMTTTTMMMMMTTTMTMTTTTMMMMTMTMMTMMMTTMMTMTMMMMTMMMTMTTMTMTMTTTTTMTMMTTTTMMTTTTMMTTMMMTMTTTTMMTTTMMTMTTTMTTTTTTTTTTTMTMTTTTMTMTTTTTTTMTTMTTMTTMTMTMTMMTTMM 62 | TTMTMTTTTTTTMTMMMMTTTTMMTTMTTMTMTTMTTMTTMTTTTMMTMTTMMTTTMTTTMTMTTTTMTMTMMMMTTTMTMMTMTMTMMMTMTMMMTMMMMMMMTMMMTTTMTMTTTTTTTTMTMTTMTMMMMTMTMTMMTMMTTTMMMMMTTMMTTMMMTTMTTMTMTMMTMMMMTTMTTTTMTTMTTTTTTMMTTMTTMTTMMTTTTTMTMMMTTMTTTMTTMTMTMMTMTMMTMTMTMMTTTMMTTT 63 | MMMTTMTMMMTMTTMMTMTMMTMMMTTTTTTTTMMTMTTTTMMTMTTTMMMTMMMTTMTMTTMTTMTMMTTTTMTMTMTTTTMTTTMTTTTTMTMMMTMTMTTMMTMMMTTMMTTTTTTMTTTTMMMTTMTTTMTMTMTMTMTTMTTMTMMTTTTTMMMTTMMTMTTTTMMMMTTTMMTMMMMMMMTMTTMTTMMTMTMTTTMTTMMMTTMTMMTMMMMTTTMMMMTTMMMTTTMMMMMMMTTTMTTTMT 64 | TMMTTTTMMMTTMTMMTMTMTTTTTMMMMMTTMMMTTMTTMMTTMMTMTTMMMTTMMMTTTMTTTMMMMTMMMMMMMMMTMMMMTMMTTMMTMTMMTTMTTTTMTTTMTMMMMMTMTTTTTTTMMTTTTTTTTTTTMTMMTTMTTMTMMMTTTMTMTTMMTTTTMMTTMMMMMMTMTMMMTMTTTMMTTMTMTTTMTMTTTTTTTMMTTMTMTMMTTTTMMMTTTTTMMTMMTTTMMTTTTMMMMTTMTM 65 | MMMMTMTMMMMMMTTMMTMTTMMMMMMTMTTTTTMTTMTMMTTMTTTMTMMMTTTMMMTTMMMTTTMTTTMTTTMTTMTMMMTMMMMMMMTMMTTTMTTMMMMMMTMTTMTMMMMTTMMTTTTMTMMMTTMMTTMTMMMTTMMMMMMTMMMTTTTMMTTTMMTMMTTTTTMMMTTTMMMMMMMMMTMTMMTMTMTMTTMMMMMMMMTTMMTTMMMMTMTTTTMMTMMMMTTTMTTMMMTTTTMTTTTMMM 66 | TMTMTTTMTTTMTTTTMTTTMTMMMMMMMMMMMMMTTTTTTTMMTTMMTTMMTTTMMMMTMTTMTTTTMTTTTTTMMMTTTTTTTTTTTTTMMTMTMTTTMTMMMTMMMMMTTMMTMTMMTTTTTMTMTMTTTTMMMTMTTMMMTTMMTTTMMMTTTTTMTTTTMTMMMTMMMMMTMMTMTTMTMTTTMTTTTTMMMTTMTMTMMMTTTTMTTTTTTMMTTMTMMTMMTMMTMMMMMMMMMMTMMTMTTT 67 | MMTTTTTTTMTMMMTTTTTTTTTTTTMTMTMTMMTMMMMTMTTTMTMMTMTMMMTMTTTTMMMTMTMMMMMTTMMTTMMMMTTTTMMMTMMTMMMTMTTTMMMTTMMTMTTTTMMTMMMTMMTTMMMMTTMTTMMTTMMMTMMTTTTTMMTTMMTMTTMTMTTMTMTMTMMMTMTTMTMTMMMTMTMTTTMMTMMTTTTMTTMTMMMTMMMTMTMTMTTTTTTTMMTTMMTTMMTTMMMMTTMTTMMMMT 68 | MTTMTTMTMTTMTTTTTTMMMTTMMMTTMMTMTMMTMTTMTTTTMTMMTTTTTTMTTMTTMTMTMMMMMMMMTTTMMMTTTTMMTMTTTMMTTTTTTMTTMMTMMTMTMMMTTTTTTMMMMMMTMTMTTTTMTMMMTTTMMTTTTMMTMTMMMTTTTMMMTMTTMMMTTMMMTTMMTTMTTTTMTMTTMTMMTTTMTTTTTTTMTTTTMMTMMTTTMTMTMTTMTTTTMMTTMTTMMMMMMTMMTTMMTT 69 | MTTTMTTTMMMTMTMTTTMTMMTMMMTMTMTMTMTTMTMMTTMTMMMTMMMTMTTMMTTTMTTMMMMTTTMMMMTTTMTTTTTMTMMMTTMTTMTMMMMMMTMTTMTTTMMTMTMTTTMMMTTMTTTTMMTTMTTMMMMTTMMMMTTTMTTMTMTMMTMMMTTTTTTTTMMTTTTMMMMMMMMMTMMMMMTTTMTMMTTTTTMMMTTMTMMMTTMTMMTMMTTTMMMMMMMTTTMMMTTMMMTMTTTTMT 70 | TMMTMTTTMTTTTMMMTMMMTTTTMTTMMTTMTTTMTTTTTMTTTMTMMTMMMMTTTTMMTTMTTMMTMMMTTTTTMTTMMMMMTMMMTTMMMMTMMTMMMTTMTMTMTMMTMTMMTTTTMMTMMMMTMTTTMTTTTMTTMTTMMMTMTTTTMMTMMMMTMMMMMTTMMTMTTMMTTTTTTTMTTMMTMTMTTMTMTMMTMMTTTMTMTTTTTMTMMMTMTMMTTTTTMTMMMMMMMTTMMTMTMMMTMM 71 | MMTTMMTMTMTMTMTMMMMMMTTMTMTMMTMTMMMMTMTTTMMTTMTTMTMTTTMMMTTMMMTMTMTTTMTTMTTMTMMMMTMTMMTTTMMMMTMMMMMTMMMMMMTMTTMMTTTTTMTTTTTMMMTMTTMMMMMTTTTMMMTMMMTTMMTTTMMTMMTTTMMMTTTMTTTTMMMMTMTTTTMMMMMMTTTTTTMMMTTMTTMTMTMMTMMTTMMTMTTTTMTTTMMMTMTMTMTTMTTMTTTMMMTMTM 72 | MMTMTMTTMTTTMMTMTTMTTTTMMMTMMMMMTTMTTTTTMTMTTMMMTMMMMTTMMMTTMTTTTMTTMMTMMTMTTMTTTMTTMTTMMMTTMTMTTMMMTTTTMMMTTMMMTMMTTMTMTMMMMMTTTMTTTMMTTTMTMTTMMTMMTMTMTTTTTMTMTTTTTTTMTMMTTTMTTMTTMTMTTMTMMMMMTTTTMMTMMMMTTMTMMMTTMMTTTTMMTMTTMMMTMTTMMTMMMMMMMMMTTMTMMT 73 | TTMTMTTMTTMMMMMTTMTTMTTTTMTMTTTTTTMMMTMMTTTTMMMMMTTMMTTMTMTMMTMMTMMTTTTMTMMTMTMMMTMMTTTTTMMTTMTMMTTTMMMMMMMTTTTTTTMMTMMMMMTTTMMMTTMTTTMTTMMMTTMTTTTMMMMTMTTTTTTTMMMMTTMTMMMMTTMTTMMTTMMMMMMTMTTTMTMMMTMTTTTMTTTTTMTTTTMMMMMMMMTMTMMTMTMTMMMMTMMMTTTTMTTMTT 74 | TTTTMTTMTMTMTMMTMTMMTTTMTTMMMTTTTMMTTMMMMTMTMMMMMTTMMTMTMMTTMTMMMMTMMTTTMMMTTMTMTTTTTMMMMTMTMTTTMTMTMTTTMMMTTTTMMTTTMTTMTMMTTTTMTMMTTTMTMTMMMMMTTMTTTTTMTTMTTMTTTTMTTMMTTTMMMTTTMTMMTMMMTTMTMTTTMTMTMMTMTTTTMMMMTTMTMTTMTMTTMTMTTMMMTMTMMMMTMMTMTTTMMMTTTM 75 | MMTTMMMTMMTTTTMMMMTTTMMMTTMMTTTMTMTMTTMMTTTTTTTTMMTMMTMMMMTMTMTTMTMTTTTTMTTTMMMMMTTMMMMMMMTTTMTTTTTTMTMTMTTMTMMTMTMTMMTMMMTTTMMTMTMMMTMTTTMMTMTTMMTMTTTTMTTTTTTTMTMTTTTTTTTMMMTTMTMTTMMTMTTTMMTTMMTTTMTMMTMTMTMTTMTMTTMMMMTMTMTTTMTMTTTMMMTMMMTTMMMTTTMMTT 76 | TMMMMTMMMTMTTMMTMTTTMTMMTTMMTTTTMMMMTMMTTMMTTMMTMTTTMMTTMMMMMTMTMTMTTMTTMTMMTTMTMTTMMTMMTTTMMTTTMTTTTMTMMTTMMTTTMTTMTMMMMTMMTMTMMTMTMTMMTTTTTMMMMTMTTMMMMMTMTMMTTMMMMMTTMTTMMTMMMTTMTMMTTMTMTTTMTMTTTMMTTTMMMTTMTMTMTMMTMMMMMMTMMMMMMTTMMMTTTMTMMMTTMMTMMM 77 | TMMMMTTMTTTMMMTMTMTMMMTMMMMMMMTTTMTTMTMMMMTMTMMMTTMMMMTTTTMTMTTTTMTTMTTMTTMTTMTTMMMTTMTTTTTMTTTTMTMTTTTMMMTTTTTTTMTTTMMMMTMTTTTTMMTTMTMTTMTTTMMMTMTMTTTMTTTTTTTMTMMTTTMTMTMTTTMTTTMTMTMMTMTTTTMTMMTMMTTTTTMMTMTMMMTTMMMTMTTTTMMTTTTTTTMMTMMTTTMMMMTMMMTMMT 78 | MMMTTMTMMTMTMMMTMMMTMTTMTTTMMTTMTTMTMMMMTTMTTMTTTTTTTMMMTTTTTMMTTMTMMMTMTTTTTMMMTMTTTTTTTTTTMMMTTMMTMTTMMMTMTMTTTMTMTTTMMMMMMMTMTTTTMMMTMMTTTMTMMTTTMMTMTMTTMTTMTTTTMMMMMMMMTTMMMTMMMMTMMMMTMTMMTTMTMMTMTTMMTMMMMTTMMTMTMMMMTMMTTTMMMTMTTTTTMMTTMMMMMTTTMT 79 | TMMTMMMTTMTTTTMTTMMTMMTMMTMMMTTMTMTTMTMMMTMTTTMTTMTMTTMMMTTTMMTTTMMMTMTTTMMMTMMMMTTTTTMTTMMMMTTMTMMMTMMMTMMMTMTMMTMMMMMTMMTMMMMTTTTMMTMTTMTTTMMTTTTTTTTMTTMTTTTTMMMMTTTTTMMMTTMMTMTTMMTTTMTMMTMMMMMMMTTMTTTMMMMMTTTTTMTTTTTTTMTMTTMMMMMTTMMTMTMMMMTTTMTTTT 80 | TTMMTTMMMMMMMMTTMMTTMTMTTMMMTMTMMMTMTTTTMTTMMMMTTMTMTMMMTTMTMMMTMMMMTTTMMTMTTTTMMTMMMTTTMTTMTMTMTTTTMMTMTTMMMMTTMMMTMMMMTMMTMMTMTTMMTTMTMMTTMMTMMTTTTTTTMTTTMTMTTTMMTMTMTMTMMMTTMTMMTTMTMMTMMTTTMMMTMTMMMTTTMTMTMTMTTTTTTMTMTTTTMMMMMMMTTMTTTTTMMMTTMTMMTM 81 | TTMTTTTTMMMMMMMMTTMTTTTMMTTMTTMTMTTMTMMTTTTTMTMTTMMTMTTMTTMMTTTTMMTMMTTTTTMTTTTTTMTTMMTTTTTMMMMMMMTTMMTMTTTMTMMTTMMMTMTTMTMMMTTMTMMMTMTTMMMMTTTTMMMMTMTTTMMMMMMMTMMTTMTTMTMMMMMMMTTTMMMMTMTMTTTMTMMMMMTMMMMTMMTTMMMTMTTTTMTMMTTMTMTTTMMMTTTMTTTMTMMMMTMMTT 82 | TMMMMMTMTTMMMMTMMMMTMMTTTTMTTMMTMTMMTMTMMMMTMTMMMMTTTMTMTMTMTTMTTTTMTMTTTTMMMTMTMMMTMMMTTMMTTTMMTTTTMTMTMTTMTMTMMMMTTMMMMMMMTTMTTMTTMTTTMMTTTTMMMTMTTTMTTTTTMMMTMMTMMMMMMMTTTMTMTMMMTTMMTTTTMMTMMTMMMMTMTTTMTTTMTMTTMTTTTMMMMMMMMTMTTTTTMTMMMMMMMMTTMMTTTM 83 | MTTTMMTMTMTTMTMMTMTTMMMTMTMMTTMTMMMTMTTMMTTMTMTTTTTMTMMTTMMMMTTMMTMMTTTMTMTTTTTTTMMTMTMTMMTMMMTTTMTMMMMTTMTTMTTMTMTTTMTTMMMTTTTTMTMMMMTMTTMMMTTMMMTMMMMTMMMMTMMMTTMMMMMTTTMTTMMTTMTMMMMTTTTMTMMMTTMMMMMMMTMTMMMTTMMTMTMMMTMMMMMMTMTTMTMMMTMMMTMMMMTTTMMTTM 84 | TTMMTMTMTMTTMTTMMTMTMTMMMMTMTTMTMMMTTTMMTTMMMMTMTTTMMMTMMTTTMTTMMTTMMMTMTMTMTTTMMMMTMTMMMMTMMTTMMTTMTMMMTTTTTTMTMMTTTMMMMMTTTTTMMTMTMMTMMTTMTTTTTMTMMMMMTTTTMMTTTTTTTTMMMTTTTMMTTTTMMMMMTTTTTMTTMTTMMTTMMMMTTMMMTMTMTTMTTTTTTMTMMTMTTMMMTTTTTMTMTTTTTMMTTM 85 | MTMTMTMTTTTTMMMMTTTTTTMTTMMTTMTTMMMTMTMTTTMMMMMMMTMTTTMTTMMTMTTMTTMMMTMTTMTMMMMTTMMMTTMTTMMTMTMMMTTMMTMTMTMMTTTTTMTTMMTMMTMTMTTMMMMTTMTMTTMTTTMMMTMMMTMMMMTTMTMTTTTMTTTTMTTTMTTMMTMMMTMTTTTMMTMTMTMMTMMTTTMTTMTTTTTTTMMMTMMTTMTTTTMMTTMTMTTMMMMTMMTTTMTMTT 86 | TTTTMTMTTMTMTMMMTTTMTTTTTMMTMMMMMMTMMMMMTMTMMMTTTMMTTTMMMMMMMMTMMTMMMMTMMMTTTTMMTTTTTTTTMTTMTMMMTMTTMMMTTTMTMTTTMTTMMMMMMTMMTMMMTTTTMTMMMTTTMTTTMTTTMMTMMTMTMTTMMMTMMMTMTTTMTMMTTMTTMTMTMTTTTTMMTMMMMMMMMMMMTMMMTTMMTMMMMTMTTMTTTTTMTMTTTTTMTTTMMMTTTMTMMT 87 | MMMTMMMMMTMMMMMMTTMTMMTMTTTTMTTMMTMTTMMMTMMTMMMTMMTMTMMMTTTMMTTMMMTMMTTTMMMTTTMMTTTMMMMMMTMTTMMMMTMMTMMTMTMMMMMTTMMMMMMMMMMMMMMTTTMMTTTMMTMTMTTTMTTTMMMTTMMTMTMTMTMMMTMMTTMMTTMTMMMTTTMTMTTMMTTMTTTTMTTMMMMTMTTTMMMTMTMTMTTMMMTTTTMTMMMTTMMTMMTTMTMMTTTMMT 88 | MTTTMMMTMTTMMTTMTMTMMMTMTMTMTTTMMTMTTMTTMMMTTMMTMMTTMTTMTMMMTMTTMTMTTTTTTTTMTTMTTMMTTTMTTMMMMTTMMTTTTTTTMMTMMTMMTTTMMTTTTMTTMMMTMTTTTMMTTMTTMMMTTMTTMMTTTTMMTTTTTTMTMMTTMMMTMTMMMMMTTTMMMTTMTMMMTMMMMTMTMTMTMMMMMTTMTTMMMTMTTTMTTTTTMTMMTTMTTMMTMMTTMTTTMT 89 | MTTTMMTTTMTMMMMMMMMMMTMTMTTTMTMMMMTTMTMMTMTTMMMTTTMMTMMMMMTTMTMTTMMTMMTTMMTTTMTTTTMTMTMTMTMTTTMMMTMTMTMMTTTTMTTTTMTMMMMMMTTMMMMTMMMTTTTMTTMTTMTTTTMTTTTTTMTMMMTTTTTMMMTMMMMTMTTTMTMMTMTTTTMMTTMTTTTMMTTMTTTMTTTMTTMTMTTMMMMMMTMTMMTTTTTMMTMMMTTTTTMMMTMTTT 90 | TTMMTTTMTMTTTTTTTMMMTMTMMMMTMMMTMMMTMTMTTMMTTMMMTMTTTMTMTTMTTTMTTTMMMMMMTTMTMTMTTTMTTTMMTMTTTTTMMMTTMMTTTTMMMMMMMMMTTTTTMTTTMMMTTMTMTTTTMTMMMTMTTMMMMTTTMMTTTTMMTTTTTTMTMTMMMTTMTMTTTMTTMTMTTMTMTMMMMMMTMTTMTMMMMMMTMMMMTMTTMMMMMTTMTMTMTMMTMTTMMMTTTMTTMM 91 | TMTTTTMTMMTMMMMMMMMTMTMTMMMTMTTMMTMMMMMMMMTTTMTTTMMMMMMMMTTMTMMMTTMMMMMTTMTTTMTMTMTMMMMTMMTTTMMTMTMTMMMMMTTMTMTMTMMMMTMTMTMMTMTTMMTMMMMMMMMTTMTMTMMMMTMTTMMMTMMTTTMMMTTTMTTTMMMMTMMMTMMTMTMMTTTTMMMTMMTTMTTTTMTTMTTTMTTTTTMMTTMTMMMMMTTTTTMMTMTTMTMTMTMMTT 92 | TTTMMTTTMTTMMMMTMMMMTMMTMMTTTMTTMTTMMTTMMTTTTTMTMMTMMMTTTTMMTTTTMTTMMMTMTMTMMTMTMMTMMTTMTTMMMMMTTTMTTMMTTMTTTMMMMTMMMTTTTMMTMTMTTTTMTMTTTMMTTMTTMMMMMMMMTMTTMTMMTMTMMMMTTMTMMTTMTTTMMMTTMMMTTTTMTMMMTMTMTMTMTMTMMMMTMMTMMTMTMMMMMMTMMMMMMTTMTTMTTMTTTTTMMT 93 | TMMTTMMTTTMTMMMTMMMTMTMTTMTMTTTMMMTMTTMTTMTTTTMMMMMTMMTMMTMTMTMTTMTTMMMTMTMMTTTMMTTMTTTMTTTMTMTTMMTTMMMTTMMTTTMMTTMTTMTMTTMTMMMTTTMMMTTTMTMTMMMTTTMTMTTMTTTTTTMTTMTTTTMTTMMTTMMMMMMTMTMMMMMTMTTMMMMMMTTTMMTMTMTMMMTTMMMMMTMTMTMMTMMTTMTTMMMMMTMMTTMMMMTTMM 94 | MMTTMTTTMMMMMMMMTTTMMMMTMTMMMMMMTTTMTTMMMTMTTMTMMTMTMTMMMTMTMMTMTMTTTTMMTTTMMTTMTTMMMTTMTMMTMTTTTTMMMMMMTMMTMMTMTMMTMMMMMTTMTMMMMMMTTMMTTMTMTMMMMMMTMMTTTTMMTMMMTTMTMMTTMTMTMTTMMTMMMTTTMMMMTTTMTMTMMTTMTTMTTTMMMMMTTTTMMMMMMTMTMMTMMMMMMTMMMMTMTTMTMTTTMT 95 | MMTTTTTMTTTMTMTMTMMTTMMTTTMMMTMMTTMTMMTMMTTTTTMMMMTMTTTTTTMMMTTMTMMTMTMTTMTTTMTTMTTTTMTTMTMTMTTMTMMTTMMMMMTTTTMTMTTTTMMMMMMMTMTTMTMTMMMTMTMTTMMMTMMMTMTTTMTTTMTMMTMTTMMTTMMTTTMMTTTMTMMMTTMMMMMMMTTTMMTMTTMMTTMMTTMTTMTMMTMTMTTMMMTMMTMMMMTMMTTTMTTTTMTTTT 96 | MTTMTTMMTTTMTMMMMTTMMTMTTMTTTMMTTTTTTTMMTMTMMMTTMTMTMTMMTMMTTMTTTMTTTMTMMTMMMMMTMTMTMMTTMMMMTTTTTTTTMMTTMTTMTMMMMTTMTTTMMTMTMMTMMTMTMTTTMMMTTTTMMMMTTMTTMMMTMTTTTMMTTTMTTMMTMMMTTMMMMTTTMTTMTMMTTMTTMTTTMMTMTTTTMMTTMTTMMTMMMMTMTTMMTMTMTMTTTMMTTTMMMTTMMT 97 | MMMTTMTMTTMTMTTMMTTTMTMMMMTTMTMTMMTMTTTTTMMTTTMMTMMMTMMTMTTTMTTTMTMTMMTTTMTTTMMTMMTTMTMMTMMTMTTTMMMMMMMMTMTMTTMMTTMTMTMTMMMTMTMTTMMMMMTMTTMMTTTTMTTTTMTTMMTMMMTTMMTMMMMMTTTMTMTMMMTMTMTMMMMMMMMMTTMTMTTMTTTTMTMMTMTMTMTTMMTMMMMTMMMTTTTTMTMMTMTTTTMTMMMTMM 98 | MTMTMMTMMTMMMTTMMMTTMTTMMTTMTMMMMTTMMTMMMMMTMMTMTTTTTTMMTTMMTMMMTMMTMMMMTMMMMTTTTTMMTMMMTTMMTMTMTMTMTMMTTMMMTTMTTTMMTTTMTTTTTMMTTTMMTMMTMMTMMMTMMTMTMMMMTTTTMTMTMMTMTMMTMMTMTMMTTTTMMMMTMMTMTMTMTMMMMTMMMTMMTMTTTMMMMMTMTMTMMTTTMMMTTMMMTMTTMMTTMMTMTTMMMT 99 | MMMTMMMMMMMTTMMMTMTTTTTTMTMTTMTMMMMTTMMMMMMMTTTTMMMMTTTTMMMTMMTTTTMMMTMMMTTMMMMTMTTMMMTMMMTTMMMMMMTTMMTMMTTTMMMMMMMMMMTMMTTMTMMMTTTMTMMMMTTTTTMTTMMTMTTMMTTTMTTTTMTMMMMMTMTTTMMMMMTMTMTTMMTMMTTTTTMMTTMMTMMMTTTMTTTMTTMMTTTTMMTMMTTMMTTTMTTMTTMTMTTTTMTTTM 100 | MTMMMMTMMTTMMTMTTMMTMTMMMMMTMMTTTMTTTMMMTTMTTTMTMTTMTMTTTMMMMTTTTMMTMTMMTTTMMMTTMTMMTMTMTTMTTMTTMTTTTMTTMTTMTMMTMTMMMMMMMTMTTTTMTTTMTMTMMMTMTTMMMTTMTTMMTTMTMMTMTTTTMMTTMMMTTTMMTMTTTTTTMMTTMMMTMTTMTMMMTTMMMMMMTMMTTMTTTTMMTMMMMTMMTTTMMMMTTMTMMMTTMMTMTM 101 | MMMMTTMTTTTTTTTTTTMMTTMMMMTMMMTTMTTMMTMTTTTMMTMTTMMTMTTTTMMTTTMTMTTTTMMMMMMTMTMMMMMTTMMMTTTMTMTTMTTTMTTMMMTTMMTMTTMMMMMMMTTTTTMMMTTTTTMTTTMTMMMMMTMMTMTTMTTMMTTMTTMTTMMMMTTMMMTMTTTTMTTMMMMMTTMMMMMMMMTTMTMMMTTTTTMMTMMMMMTMTTMMMTMTMMMMMTMTMMMMMMMMMTMTTT 102 | MTTTMMTMMMMTTTMMTTTMMTTTTMTMMTTMTTTTMMMTTTTTTMMTTTMTMMTMMMTTTTMMTMTTMTTMMMMTTMTMTTTMMTMTTMTTTMTMMMTTMMMTMTMMTMMMMMMTMMTTMTTMMMMTTTMMTMMMTTMTMMMMTMMTMTTTMMMTMTTMTMTTMMTTMTTTMMTMTTMMTTMTTTTTMMMMTTMTMTMMTTTTTMMMMMMMTMMMTMTTMMMMMMMTTTTMTMTMMTMTMTMTTMTMTT 103 | TMMMMTTMMMTMTTMMTTTTMTMTMMTTMMTMTMTTTMMTTMTTTMTMTTTTMTTMTMMTTTMMMMTTTMMMMTMTTTTTMTTMMMMTTMMMMMMTTTMTMTTTTMMTMMMTMTMTTTMTMTTTTMMTMMTTMMMTMMTMTTMTTTMMMTTTTTTTTTTMTTMTTTMMTTTTMMMTTMTMTMTTTTTTMTMTMTTTTMTTTTMMMMMTMTMTMTTTTMMTMMMMTMMMMTMMTMTTTMTMMTMTTMTTMM 104 | MTMTMMMTMMTTMTTMTMTTMTMTMTMMMTMMTMMMMTTMTMMTTTMTMMTTMMMTTMTTMMTTMTMMMMMMMMTMTTTMTMMMMTTMTMTTTMMTTTMMTTTTTTTTTTTMTTMMMMTMMTMMMTTTTMTTTMTMMMTTMTTMMMTTMTTTTTMMMMMTMMMTTTTMTMMMMMTTTTMTTMTTMMMTMTTMTTMTTTMTTTTMMTMTMMMTTMMTTMMTMTTTMMTTTTMTTMTTMMTTTTMMMMTTTM 105 | MMMTTMTMTTMTTMMTTTTTMTMTMMMTMMMTTMMTTMTMMTTMTMMTMTMTMTTTMTMMMTMTMTMMMMTMMMTTTTMMTTMMMTMTTMTTMTTTMTMTTTTTTMMTTTMTTTMTTMTTTTTMTTMTMTTTTMMTMMMTTTTTMMTMTTMMTMMMMTMTMMTTTTMMTMTTMMTTMTMTMMMTMMMMMMMTMMMMMMMMMMTTMMTMTTTMMTTMTMMTTMMTMMTTMMMTTMMTMTTTMMMTMMTTMT 106 | MTTTTTTTMMTTTTTMMTTMMTTMMMMMMTTMMTTMMMMTTTTMMMTTMTMMTMTTMMMTMMMTMMTMMMMMTMTMMMTTTTMMTTMMMTTMMTTTMMTTMMMTMTTMMMMTMTMTMMMMMTTTTMTTTTMMMMTMTTMTMTTMTMMTMMTMTTTTMTTMMTTTMTTTMMMMTMMMMTMMTTMMTMMTTTTTMTTMMTMTTTTTMMMMTMTMMMTMTMTTMMMMTTMTMTTTMTMMTMTTMMMTTMMTTM 107 | MTTTTTMTMMTMMMMTMTTMTMTMTTMTTMTTMMTTTTMMMMMTMTMTTMTMTTTTMMTMTTMMMMTMTTTTTTTTTMTMTTMTMTTTTMTMTMMMMTTTMMMMTMTMMTTTMTMMTMMMMTMTMMTMTTMMTMMTMTMTTMTTMMTTMTTMTTMTTMTMMMMTMTTMMMMMTTMMTMTMTMTMMTTMMMTMMMMTMTTMMMMMTMMMMTMTMTTTTMTTTMMTTTTMTTTTTMTMTMTMMMTMMTTMTM 108 | MMMTMTTTTTTTMTTTMMTTTTTMMTMMMTMTTTMMMMMTMTTMTTTTMMTMMTMTMTMTTTTTMTMTTTMTMTTTTTMMMTTTMMTMMMTTMTMMTMTTTTMTMTTMMMTTMTMTMMMMMTMMTTMTTMMTTMTTTTTTMMTMMTTMMMMMMTTMTMMMMMMTTMTMMMMMMMMMMTMMTMTTMTMMTTTTMMTMTTMMTMMTTTTTTTMTTMTTTTTMTTMMMTMMTTMMMTMTMTTTTTTMMTMMMM 109 | MMTMTTMMTMTTMTTTTMMMTTTTTMTTMTMTTTMMTMTTTMTMMTTTTMTTTMMTMTTMMTTTTMMMMMMTTTMTMMMTTTTMTMMTMTMMTTMTMMTMMMMMMTTTMMTMMTMTMTMTTMTMTTMMTMMTMTTMMMMTMTMMTMMMMTMTTTTTMTMMTMMMMMTMTTMMMMMMTTMTMMTTMTMMTMMMTMMMTTMMMMTMMTMTTMMMTMMTTMTTMMMMTMMTMTTMTTMMMMMMTTTMMMTMTM 110 | TMTMMMMMTTTTMMTTTTTTMTMMMTTTTTTTTTTTMTTTTMTTMTMMMTTMTTTMTMMTMTMTMMMMMTTTTMMTMMMMTMTMMTMMTTTMMMTTMTTTTMTMMMTTMMTTMTMMTMMMTMMTMTMMTMMMMMMMMMMTMTTMTTTMMMMTMMTTMMTMTTMMTMMMTMTMTMTTTTMMTMMTTMTMMMTMTMTMTMTMTTTMTTTMTTMTTMMMTMTMTMTMMTMMTTMTTMTTTMTTTMMMTTTMMM 111 | TTMTMMTMTTMMTMMMTTTTMMMMTTMMMTTMMTTMTMTMTMTTMMTTMMTMMMMTTTTMMMMTMMMTTTMMMMTTTMTTMTMTTTTTMMTMMMMTTMTTMTMMMTMMTTTMMMTMMMMTTMMMMMTTMMTTMTMMMMTMTMMMTTTTMMMMTMMTTTMMMTTMTMTTTMTTTTTMTMMMTTMMMMTTTTTTTMMMTMMMMTMMMMMTTMMMMMTMTMTTMTTTTMTTTMMTTMTMMMTTTMMTMMTMMM 112 | MTTMMTTMTMTTTMMTMMTTMMTTTMMMTTTMMMMMTTTMMTMTMTMTTMMTMMTMTTMMMTMMMMTMMTMMMTTMTTTTTMMTTTTMTMTTTMMTMMTTMMTMMMTMMMMMTMTTMTMMMTTMMMMMMMTTTTMTTMTTMTTMTTMTTTTTMTTTTMTMMTMMTMTTTMTTMTTMMMMTMMMTTTTMTMTMTTMTMTMTMTMTTMMTTMMTTMTTTTMTTMTMMTTMMTTTTTTMTTTTMTMTTMMTMM 113 | TMTTTTMTTMTTTTTTMTTMMTMMMTTMTTTTTMMTTTTTMTMMTMMTTMMMTTTTTTMMMTTTMMTMTTTMTTMMTTTMMTTMTTMTMTTTMTTTMTMTMTMTTMMMTTTMTMTTMTMTMTTMTTMTMTMMTMMTMTMTMTTMTTTTMMMMTMMTMTMMMMMMTMMMMMTTMTMMMMMMTTTTTMMTMTMTMTTTMMMTMMTTTTMMMTMMMMTMMMMTMMMTTMTMMMTTTMTMTTTMMTTMTTTMTM 114 | TMMMMTMTTMTTTMMTMMMMMMMMMTTTTTTTTMTTTMTMMMTMMTTTTMMMMMTMTTTTTMMMTTTMMTMTMMMMTMTMMTMTMMTMMTTTMMMMMMTMMTTMMMTMMMTTMTTMTTMTMMTTTMMMMMTTMMTTMMTTMMMTTTMTMMMTMTMTTMTTMTTTMMMTMMTTMTMMMTTMTMMMTMMMTTMMMTMTTMTMMTMTMMMMMTTMTMMTMTMTTMTTTTMMTMTTTMTMMTTTTMMMMTMMTT 115 | TMTMMTTMMMTTTTMTTTTMTMTTMTMMMTTMMTTMTMMMMMMMTTMMMMMMTMMTMTMTMTMMTTTMMMMTMTMTMTTTTMTTMTMMTMTMTMTTTTMTTTMMTMTMTMMMMMMMTTTTTMMMMTTMMTMMTMTTTTTMMMMMMMMMMTTTTTMTTTTMTMTTTMTTMMMTMMTMTMMTTMTMMTTMTMTMMMMMMMMTMMMMTTTTTMMTMMTMTTMTMTMTTMTMMMTMTTTMMMTMTMTTMMTTTT 116 | MMTTTMTTTMTMTTMTMMMMTTTTMTTMTTMMMMMTTTTMTTTMMMMMMMTMTTMMTMTMMTMTTTTMMMMTTTMTTMMMMTMTTMTTMMTMTMMMTTMMTTTTMTMTMMMMTTTMTTTMTMMTTMMTMTTTMTMTTMTMTMMTMTMMTMMTTMMMMMTMMMTMTTMMTTMTMMMTMTTTMTTMMMTMMMTMMTMMMTTMTTTMMTTMMTMTTMTTMMMTTTTTTTMTTMTTTTTTTMTMMTMMTMTMMM 117 | TTMMTMMTTMTMTTMTMMTTMTMMTMTTMMMTTTMTMMMTTMTTMMTMMMMTTTTMMTTMTMMMTTTTMMMMTMMMMMTMMMMTMMTTMTTMMMTMMTTTMMTMMTTMMMTTTMTTTTMMMTTTMMTTMMTMTTMTMTMMMMMTTMTMMTMTMMTTMMTTTTMTTTTMTTTTTTTMTMMMMTMTTTMTTMTMMMMTTMMMTMMMMMMMTMTMMTTTTTMMTTMMTMTTTTMMMTMTTTTTTTMTMTTTMM 118 | TTMMMMMMMMMTTTTMMMMMMMMMMMMMMTMTMMMTTTTTMTMMTTTMTMTMMMTMMMTTMTMTTTMMTTMTTTMTTMMMMTTMTTMMMMTTMMMMTTMTMTMMTMTTTMTMMTTMTMTMMTMTTMMTMMTTTMTMMTTTTMTTMMTMMMMTTTTMMMMMMMTTTTMTMMTTTMMMMMMMMMTTTTTMMMTTMTMTMTTMTTTTMMTTMTTTMTTTTTMMMTMMMMTMMTMMMMTMMTMTTTTTTTTTMT 119 | MTMTMMMMTMMTTMTMMTMTMTTTTTMTMTTTTTTMMTTTMMTMTTTMTTMTTTTMMTMTMTTTMMMTTMMTTMTMTTTMMMTMTTMTTTTMMTTTTTTMMMTMTTTTMMMMMTTMMMMTMTMMTMMMTTMMMMMTMTMMTMTMMTTMMTTTMTMTTMMTMMMTMMTMTTTMTTTMTMTMMMTMTMMTTMMTTMTMTMMTTTTTMTTMMTMTMMMTTTTTMMMTMMMTTMMMTTTTTMTTMMTTMTMMTM 120 | MTTMTMMMTTMTTTTMMTMTMTMTTTTTTMMTMMTMTTTTTTTMMMTTTTTMMTMMTTTTMTMTTMTMMMMMMTMTMTTMTTTMMTMTMMTMMMMMMTMMTMMTMTMTTMTTMTMTMMTMMTTMMTMTTTMTMMTMTTTMMMMTMTTTTMMMMTTTMTMMTTTMTTMMMTMMTMTTTMTMMMTMMTTTMTTTMMMMMTTTTMTMMTTTTMTTMTMTMTTMMTTMTTMTMMMTMMMTMMMMTTTTMMMMTM 121 | TTTTTMTTMTTMTMTMMMTTTMTTMMTMMTMTMTMMMMMTMMMTTMMTTMMTMTMTTTTTTTMMTMMMMTTMMTTTTTTMMTMMMTMMTMMTMTTTMMTMTMTMTMMMTMMTTTTTTTTTTTTTMMMMTMTTTTMTTMTTTMMMTTMTMMMMMTTTTTTTTTTTTMTTMMMMMMMTMMMTTMMTMMTMTTMTTMMMMTMMTTTTTMTTMMMTTTTMTMMTMMTMTMTTTMTTTMMMMTMMMTMMTMMMTT 122 | MTMTTMTTMTMTTMTMTMTTTTTMTMMMMMTMMMTTMTMMMMMTMMTTTTTTMMTMTMMTMMMTTMMMTTMMMTTMMMTMMTTTMTTMMTTMMTTMTMTTTTMTMMTMMMTTTTTTTTTMMTMMTTMMMTMMTMMMTTTMTTTMMTMMMMMTTMMMMMMTMTMTMMMMMMTMMTTMTMMMTTTMMMMTMMTMTTTMTMTMTMTMTTMMTMTMTTMTTMMMMTMTTMMTTTMMTMTTMTMMTTTMMTTTMM 123 | TMMMTMMTTMTMMMTMTTMMMMMTTTMMMMTMMMMMTTMMTMTMTTMTTTMTTTTTTMTTMMTTMMMTTTMMTTMTMMMMMMTMMTMTTMTMTMMTMMMMTMTMTTMMTTMMMMMTTTMTMTMTTMTMTMMMMTMMMTMMTMMTTMTTTTTMTTMTMTTMTMMMMMTMMMTMMMTTMTTMTMTTTTMTTTTMTMTTMTTMMMTTMMMMMMTMTMTTTTTMTTMTMMTMMMMTMTTMTTTMTMMTTTTMMT 124 | TTMTTTMTTTTTTTMMMMMMTTTTMMTMMMTMMTMMMMTTMMMMMTMTMMTMTTTTMMTMMMTMTMTTMTMTTTMTMTMTMTTMMMTTMMTMTTTMMTMMMTTMMMMMMTTTMMMMTMMTTMMTTTTMTMMMMMTMTMMTMTMTMMMTMMMMTMTMTTMTMTTMMTMMTMTMMTTTMMMTMMMMMMMTTMTTTTMMTMTTTMMMTMTMMMMMMMTTMTTMMMTMMTMMTTTTMTTMTTTMTMTMTMTMTT 125 | TTTTTTTTMTTMTMMTMMTMTMTTTTTTMMTTMMTMMMMMTMMTTTTMMMTTMMTMMMMTMMTTTMTMTTMMTTMTTMTMTTTTTTMTTMTMTTMTMTMTTTTMMTMMMTTTMMMMTTTTTTMTMTMTTTMTTTTTMMMMMMMTTMTTTTMMTTTTTMTMTMMMMTMTMMMTTTMTTMMMMMTTMTMTTTMMMTTTMMMMTTTMMTMMTTTMTMMMMMMTMMTTMMMTTMTMTTTTMTTMMTTTTMTTTM 126 | MTTMTTMMMMMMMMTTTMTTTTTTTMTTTTTTMMMTTTMMMMMMTMTMMTMTMMTMTMMTTTTTMTTTMMMTMTMMMTMMTMMMTMMMMTTTTTMMTTTTTMTMTMTTMTMTTTTMTMMMMTMMMTTTTTMTMMTTTMTMMTMTTTTMTMTMMMTMTTMTMMTTMTMMMTTTMTTTTTMTTTMTMTMMTTMMTMMMMMMTMTTMMMTTMMMMMMTMTMTMMMMMTTMMMMMMTTMMTMTTTMMMTMMTTT 127 | MTMMMMMMTTTTTMTMMMMTMTTMTTMMTTMTTMMMTMTMMTMTMMMMTMMMMMTMMMTMMMMMTMMMMMMMMMTMMMMMTMTTTMMMMMMMMTMMTTTTMTTMTMTMTTTTTMMMMMMMTMMMMTTTTTTMMMTTMMTTMTMMMMTMMMTMMMTMTTMTMMMTMTMTMMTMTTTTTTTTTMMTTMMMMMTMTTTMTMMMMTMMTMTMTTMTMTTTMMTTTTTTMMTMTTTTMMMMTTMTTMTTMTTTTT 128 | TMTTTTMTTMTTMMTTMMMMMTTTMTTTMTTTMTMTTTMTMTTTMMMMMTMTTTTMMTTTMMTTTTTTTTMMMMTTTMMMMMMTMMTMTMTTTTTMTMTTTMMMMMTTMTMTMMMTMMTMMTMMMMMTTMMMMMMMTTTMTMTMTTMMMTMMTMTTMTTTMTTMTTMTTMMTMMMMMMMMTTMMMTMTMTTTMTTMMMTMMMTTTTTTMMTMTTMTMTMMMTMTMTMTMTTTTTTTTMMTTMMTMMTTMM 129 | MTMMMMTMTTMMTMMMMTTTMMMTMTTMTMMTMMTTTTTMTTMMTTTTMTTMMMMTMMTMTMMMMTMTMTTMMTMMTMMTTMTTTTMTTTTTTMTTMTTTMMTTMMMMMTTTMTMMTMMTTTMMTMTTMMTTTMMMMTMTTMMTMTMMTTTTTMMMTTMMMMMMTTTMMMTMMTTTMTMMMTMMMTTMMMTTMMTTTTTTTTTTMMMMTTTMMMTMMTMTTTMMTTTTMTMMTMMMTMTTTMMTMTTTTM 130 | MTMTTTMMMTMTTMMTTMMTMTTMTTTMMMTMMMMTTMTTTMMMTTTTTTTMTMTTMTMTTTMTTTTMMTTMMTMMMMMTMTMTTMTMMTTTMMMTTMMMMTTMMMTTTMTMTTTMTTMMMTTTTTMTTTTMMTMMTTMTMTMMTMTMMTMTMMTTTMTMTTTMTMTTTTMTMTMMMTTMTMMTMTMTMTMTTMTTMTMMMMTTMMMTMMMMTTMTTTTMMTMTTMMMTTTTTTTTTTMMMMMTMMTTMT 131 | MMTMMMMMTMTMTTTTTMMTTMTTTTMTTMMMMMTTTMTTMTTTTTMTMMMTTTMTTTMMMTMTMTMMMMMTMTTTTMTTTTTTTTMTMTTMMTTMTMTMMMMTMMTTMTMTMMMTMMTMMTTMMTMMMMMTMMMMMMTMMMMMTTTTMTTTTMTMTTMTTTTMTMMMTMTMMMTMMTTTTMTMMMTMMMTMTMTTMMTTTMMMTMMTMTMTTTMMMTTMTMMMTMTMTTTTMMMMTMTMTTTTMTMTTT 132 | MMTTMTMMTMTMTTTTMMMTTTTTTTTTMTMTMMMTMTTTTMTTTMMTMMMTTMTMMTMMTTTMTMTMTTMTTTTTTTMTMMTMMMTMMMMMTTTTMTMMTMMTTMMMTTMMTMTTTMTTTTTMTMTMTMTTTMTTTMTTTTMTTMTTTTMMMTTMMMTMTMMMTMMTTMTMMMTMMMMMMTMTMMTTMMTTTTMTMMMMMTMTTTMTMMTTTTMTMMMMTMMTMTTTTTTTMTMTMMMMTTMMMTTMTT 133 | MTTMMMMTTTTMTMTTTTTTTMTMMMMTMTTMTTMMTTMMMMMMTTTTTMMTMMMTTMMMTTMMTTMMMMTMTTTMTMTTTMMMTMTMTTMMMMTMTMMTMTTMMTMMMTMMMTTTMTTTTMTMTTTMTTTTTTMTTMMTMTTMMMMTTTMMMMTTMTMTTMTTTMMMMMTMMTMMTTTTMMTTTTTMTTTMMTTTMMMTMTTTMMTMTMMTTMTTTMTMTMTMTTTMTMTMTMTTTTTTMMMMMTMMMT 134 | MMMTTTTTMMMTTTMTTMTTTTTTTMMTMTMTMMMTTTMTTTMMMTMMMMTTTTTMTMMTMTTMTTMTMTMMTMTMTMMMTMMMTTMTMTTMTTTTMTMMTMTTMTTMTTMMMTTTTTTMMMMMTTTMTTTTMTTMMTMMTMMMTMMMTTTMTTMMTMMMTMTMMMMMMMMMMMTMMMTTTMTTMTTTMTTMTTTTTMMMTMTMMMTTMTTMTTMMTMMTTTMTMMTMMTTTMTMTTTTTMTTTTTTMTM 135 | MMTTTTTTTMTTTMMMMMMTTTMTMTMMTMMMTMTTTMTTMTTMTMMMTTTMMMTTTTMMMTMMTMMTMMTTMTMTMMMMMMMMMTMMMTMMTMMTTMMMMMMMTMMTTTMMTTTTTTTMMTTTTTMMMTMMTTTMTMMMTMTMMTTTTMMMMMMTMMMMTTMMMTTTTMMTTMTMMMTTTTMMMTMTMMTTTMTMTMTTTMMMMTMMMMTTMTTMTTMTMTMMMMMMMTTTTMTTMTMTMTMMMTTTMM 136 | TMTMMMMMMTMMMMTTTMTMMMMMMMMTMMTMTMMTMTMTMMTMMTTTTTTMTTTTMMTTMTMMMTMTTMMTMMTMTMTTMMMTMTTMMTMTTMTTMTMMTMTMTMTTTMMTMMTMTTTMMMTMTMTTTMTTTTTTTTMTTTTTTTTTMTMTMMTMTTMTTTTMTMMTTTTMTTTTTTMTMTMMMTMMMTMMTMTTTTMMTMMMMTMMTMMMTMTMTMTTMMMTTTTMMTMTTTTMMTTMMMMMMMMTTT 137 | MMMTTTMTTTTTTTMTTMMMTMMTTMTTMTMTMMTMMMMMMMTTMTMMTMMMTTMTTTTMMMTTTMMMMTMMTTMTMTMMTMMTMMMTTMMTMMMMMMTTTTTMTTMTMTMMMMTTMTTTMTTMMMMTMMMMMTTMMMMMMTMTTTMTMMTMMTMMTMTTTMTMTTMMTTTTMTTTMMTMMTTMMMMMTTMMMTTMTMMMMTMMMTMTMMMTMTTTTTTMTMMMTTMTTTTMTMTMTTMTTTMMMMTMTM 138 | TMMMTMMMTMMTMMMMMMTMMMMMTMMMTTMTMMTTMMMMMMTMTTMMMMMMMTMTMMTMTTMTMMMMMMTMTTMMMMTTMMTMTTTMTTMMMMTMTTTMMTMTMMMTMMMMTMMTTMMTTMMMMTMMMMTTMMTTMTTTTMTMTTTMMMTMMTMTMMTMMTTMTMTTMTTTTMMTTMTTMMMMMTTTTMMMMMTMMTMMMTTMTTMTTTTTMMMMTTTTMMMMTTTTTMMMTMMMMTMMMTTTMTTTTT 139 | TTTMMTMMMTMMTTMMMMTMTMMMTTMMTTTMMMMMMTTTMTTMTMTMMTMTTMTMMMMTTMMTTMMMMMMTTTTTTMMTMMTTTMMMTMMMMMTMMMTMTMTMTMTTMMMMMMMMMTMMMMMMTTMMMMMTTTTMMTMMTMTMTTMTMMTMMTMTTTTMMTMMTMMMTTMTTMTMTMMMTMMTMMTMMTMTMTTMMMTTMMTTMTTMTMTMMMMMTMMTMTTMTMMTTMMTTMMTTTMMMMMMMMMMTT 140 | TMMMMMMTTTTTTTMTTMTTMTTMTTMMMMMTMMMMMTTTMMMTTTMMTTMTMTTTTMMTMMMTMTMMMTTMMTMMMMMTTMTMTMMMMTTTTMMTMTTTTTMTTTMTMMTTMMTTMMMTMMTMTMTMTMTMMMTTTMTMMTTMTTTTTTTTTTTTTTMMMMMMTMTTMMTMMMTMMTTMMMMTTTMMTMTTMMMMMMMMTMMMTMTMMTTTTMTMMTMTTMTMTMTMMMMTTMMTMTTTTMTMMMMTTT 141 | TMTTMMTTMMMMTTMMMMMTTMMMTTTTTTMMMMTTMMTTMTTMMMTMTTMMTTMMTTMMTMTMMTTTTTTTMMTMMTMTMMMMTTTTTMTTTTTTTTTTMTMTTTMMTMMTMTTMMTTTTTMMMMMMTTTTTTTTMMMTMTMMTMMMTTTMMMTTTTTTTMTTMTMMMMTMTTTMMMTTTMTMTTTTMMMTMMMTMTTMMTTTMTTTTTMMMMTTMTMMMTMMMMMMMMMTTMMTTTTMTTMMTMMMMM 142 | TTTMTMMTTMMMMTMMTTTTMMMTTMMMTTMTMMTTTTTMTMTMMMTMTTTTTTTTTTMMTTTTMTTMMMMTTMTTMMMMTTMMMMMMTMTTMMMTMTTTTTTTTMMTTMMMTTMTMMMMMTTMTTMMTMMMTMTTMTMMTMTTMTTTTMTTTTMMTTTMMTMMMTMMMMTTMMTTMTMTTTMMTMMTMMTTTMTTTTMTTMTMMMTMMTTMMTTMMMTTMMMTTTTTTMTTMMTTTTMTMTMTTTMMTM 143 | MTMTMTTMTMTTTTTMMTTMTMMMTMTTTMMMTMMMTTMMTTMTTTTMMTTTTMMTMTMTTMMTMMTTTTMTTTMTTMMTMMMMTMMMTTMTMMTMMTMTMTTMTMTMTMTMTMMTMTTTMMMTTMTTTMTMTMMMMMTTTTTMMMMMMMTMTTTTTMMMMMMTMMTTMMMTTMTTTMTTMMMTTTTMMTMMTMMMMMTTTMMMTMTMTTTMTTMTMTTMTMTTTMTTTMTMMMMMMTTMTTMTMMTTMT 144 | MMMMTTTMMTTTTMMMTTMTTTMMMMMMTTTTMMMTTMTTTMMMTTMMMMMMTMMMMTTMMMMTTMTMTMMMMMMMMMTTTTMMTTMTMTMTTTTMMTTMMMTMTMTMTTTMTMMTMMTTMMMMTTTTMMTTMMTTMTTMMTTTMTMMTMTMMTMTMMMTTTMTTMTTMMMTMTTTMMMTTTTTTTMMTTMTMMMTMMTTTTTTMTTMTMMMMMTMTTMTMMMMMTTMTTMMTTTMTMTTTMTMTMTTTM 145 | TMTMTMTMMMMMTTMTTMMMTMTMMMTMTMTMTMTTMTTTTMMMMTTTTMTMTTMMMTTTMTTTTTTTMTTTTMTTMTTTTMMMTMTMTTMTMMTMMTMMMMMTMTTTTTMMTMMTMTMTTMMTTMTMMTTMMMMMTTTMMMTMMTMMTMTTMMTMTTMTMMMTTMMMTTTTMMTMMMTMTTTMTMMMTTTMTMTMTMMMMMTTTTTMMMMMMMTTTMTMTMMMTMMMTTTTTMMTTTTMMMTMMMMTTT 146 | TMTMTMMMTMMTMTTMMTMMMMTMTMMTTTMTMTMTMTTTMMTMTMTMTTTTMTTTTTTTMMMMTTMMTMTTTMTTMMMMTMTTTTTMTTMTTTTTMMMMMMMMMMTMTMMMMMTMTTTTMMMTTTTMTTTTMTMMMTTMTMTTTMMTTMMTTTMTTTMMMMMTTTMTMMMMMMTTTMMMMMTMTTMMMTMMTTMTTMTTTTMTTTMMMMMMMTMMMTMMMTMMMTTTTMMTTTTMTTTTTMTMTMMMTM 147 | TTTMMMMMTTTTMMTTMTTTTTTTMMTMTMMTMTMTTMMTMTTMTTTTMTTMMTTMMMTMTMMMMMMTTMMTMMTMMTTMTMTTMTTTMMTTTTMTTMMTTTTTMMMTMTMMTTTMTMTTTTTTTMTTMMTTMTTTTMTMMMTTMTMMTMTTTMTMTTTTTTTTTTMTTMMTMTTTMMMMMMTTMTMTTTMTMMTTMMMMTTMTTTMTMMTTTMMTMMMMTMTMTMTTMMTTMTTTMMTMTTTMMMTTMT 148 | TMTTTMMMTTTMTMTTTMTMTMMTMTMMTMTTMMMTTTMMMTTTTMTTMMMTMTTMMMTTMMTMTMTMMMMTMMTTMTMMTMMTTMTMMTTTTTMMTMMTTTMTTTTTTMMTTTTTTMMMMTTTMTTTMTTMTMTMMMMTTMMTMTMMMTTMMMTTTTMTMTMMMMTMTMMMTTMMMTMMTTTTMTTMMTTMMTMTTMTMTTMMTMMMTMMTTTTMTTMMMTMMTTTMMMTTTMTTMMMMTTTMMMTMMT 149 | MTMTMMTTTMTTTMMTMMMMTMMMMMTMTMMTMMTTMMMTMTMMTTMMTMMTMMMMTMMMTTMTMMMTTTMTTMTMTMMMMMTMMMMMTMTTTTTMMTTTMTTMTTMMMTMMTMMTTMTMMTTMMTMTMTMMMTTMTMTTTTTMMTTTTTTMMTTTTTMTMTMMTTMMMMMTMTTTTTTMTTMMMTTTTTTMMMMTMMTMMMTTTMMMMTTTTMMTTTTTTTTTMMTTTTMTMTMTTTMMTMMMMTMMMM 150 | MMMMTMTTMTTTMTTMMMMMTTTTTTMTTTTMTTMMMMMMTMMTTMMTTMTMTTTMTMMMMTTTTTMTMMMMMMMMMTMTMMMTTTMMMMTMTMMMMMMMTMTMMTMMTTMTMTTTTMTMMMMTTTTTMTMMMMMMTTMMTMMTMTMMTTTTMMTTTMMTTMTTTTTTMMMMTMTMTTMMMTTTTTTMTMTMTTTMMMMMTMMMMMMMTMTMTTMMTTMMMMTTTMTTMMMTMMMTMTTMTMTMMMMTTT 151 | TTTTMTMTTTMMTMMTMMMMTMMMMMTTTMTMTMMTMTMMMMMMMMTMMMTTTMMMTMMTMMMMMTTTMTTTMMMMMTMTMTTMMMMMMMTMMTMTTMTMMTTMMTTMTMMMMTMTTTMMTTMTMTTTMMMMTTMMMMMMMTMMTTTTMMMMTMMTTTMTTTTMMMMTTTTMMMMMTMMMTTMMMMTMTMMTMTMTTMTTMTMTTTMTMMMMTTTMTMTTMTTTMTTMMTMTTTTTMMTMMTTMMMMTTT 152 | MMTTMMMMMTMMTTMTTTMMMTTTMTMMMTTMMMTTTTTMTMTTMMTMMMTTMTTMMTTMMTTTMTTTMMTTTTMMMMTMMMTTMMMTTTMMMMMTMTMMTMTTMTMTTMMTMMMMTMMMMMTTMTMMMTTMMTMTTMTTMMTTMMMMMMMTMMTTTMMMMMMTTMMMMMMMMMMMTTTMTTMTMMTTTTTTMTTMTMTMMTMMTMMMMMTTMTMTTMTMMTMTTTMTMMMTMMTMMMTMMMMMMTTTMM 153 | MMTMTMMTTTTTMMMMTMTMMMTMTMTTTTMTMMMMMTMMTTTTMMMTMMTTTMTMMMTMMTMMMTMTTMTMMMTMTMTTMMTTTTTTMMTTTTTTMTMTTMMMTTTTMTMMMTTTMMTMTTMTMMTTMTMTTMMTMMMTMTTMTMTTMMTMMMTMTMMTTTMMTMMMTTTTTMTTTTTTTTMTMMTTMTTTMTMMMMMMMTTTMTMMTTTMMTMTMMTMMMTMTTMMMTTMMTMTMMTTTMTTMTTTTT 154 | MTTMTTTMTMMTMMTMTTMTMMMTMTMMMMTMTMTTTTTTMMTMTTTTTMTTMTTTMTMMTTTMTMMMTMTTMTTTTMMMMTTMTTTTTMTTMTMMMMMMMMTMMTTMMMMTTMMMTTTMTMTMTMTTTMTTMMMMMTMMMTTMMTMMTMTTMTMTTTTTTTMMTMTTMMMTTMTMTMMTTTTMTTMMMMMTMMTTMMTMTTTTTMTMTMTMTTTTMMTTTTMTMTTTTTTTTTMMMTTTTTTMMMTMTT 155 | TTTTTMTMTMMMMMTTMTMTTMTMTMTMMMTTMTMMMMMTMMTMTMTTMMMTTTTMMMMTTTTTMTMTTMMTMTMMMMMMTTMMMMMTMTTMMTTTTTTMMTMMMTMTTMTMTTTTMMTTMTMMTMMMTTMMTTMTTMTTMTTTTMTTMMTTTMTTTMTTMMTTMTTMTTMMTMMMMMTMMTMMTMTMMTTTTMTMTTMMTMTMTMTMMTTMTTTTTMMMMMTTTMMMTTMTTTTMTMMTTTTMTMMTMT 156 | MTMMMTMTTTMTTTMTMTTTTTMTMTTTMTTTMTTTTTTTMMMTTTTMMTMTTTTTMTMTTMMMMTMTMMMMTTMTMMTTTMMMMMMMMTMMTMMMTMTMMTMMTTTTMMTMMTMTMTMTMMMTTTTTMTTMMMTTTTTTTMMMTMTTTTMMTTTMMTMMMMTTMMTTTMMTTTTMMTMMMTMTTMTTTMTTTMTTTTTTMMTMMMMTMTMMMTTTTTMMTMMMTMMMMTMMMTTMTMTMMTMTMMMTMT 157 | TMMMMMTTMMMMTMTMTMTMTTTMTTTTTMMTMTMTTMTMMMTTTMTTTMTMMMMTMMMTTTMMTTTMTTMTTMMMMMMTTTTTMTMMTTTMTTTTMTMTTMMMTMMTTMTTTMMTMTTTMTMMTTMMTMMMTMTMMMTTMMMMTTMMTMMMTMTTTMTMTTTTMMTTMMMTTMMTMTTMTMTTMMMTMTTMTTMMMMMTMMTMTMTTMMMMTTMMTMMTMMTTMTTMTMMTTMMMMMMMMTTMTTTMTM 158 | TTTTTTTTTTMTMTTMMMMTMMTMMMTTTMMMTTTTTMMTTMMTMTMTTTMTMMTMMTTTMTMTTTMMTTTTTTTMMTTTMMMMMMTTTTMTTTTTMMTMTMTTTTTMTTMMTMMTMTMTMMMMTMTMMTMTMTTTMTTMMMMTTTMMMTTTMMMMTTMMMMMMMMMTTTMTMTTTTTMMTTMMTTMTMMTMMTTMTMTMTTTTMTTMTMMTTMMMMMMMTMMTMMTTTTTMMMMTMTMMTMTTMTTMMT 159 | MMMTTTMMTMMMTTMMMTMMTTMTMTMTTMMMTMTTTMMMMMMMMTTTMTMTMTTTTMMTTMTTTMMTMMTMMTTTTTTMTTMTMMTMMTTTTTMTMMTMMTMTMTMMMTMTTTMMMMMTMTTTMTTTMTTTTMMTTTMTMMMMTTMMTMMTTMTMMMTTMTTTMTMMMTTMMTMTMTMTMTMMTTTMMMTTMMMTMMTMTMMMMMTTTMTTMMMMMTMTTMMTTMMTMMTTMMMTMMMMMTMTMTMMTM 160 | MMMTTTMMTMTMTTTMMMMTTMMTTTTMMTMMMMTMMMTTMMTTTMTMMTTMTTMMMTMMTTTTTMTTMTMTTTTTTMTMMTMTMTMMTTMTTTMTMTMTMMTTTMMTMTMTTTMMMMMTMTMTTTMTTTTMTTMMTMMMMMTTTTMMTMTMMTMTMTMMTMMTMTMMMTMTMTMTMMMTMMTMTTTTMTMMTTMMTTMMTTMMMMTMTTMTTTMTMMMTTMTTMMTTMMMTMTMTMMTMTMTTTMMMTT 161 | MMMMTTMTMMMMTMTMMTTTMMTMMTMTTTTTMMMMMTTTMMMTMTMMMTTTMTTMMTTTTTMTMTMMTTTMTMTTMMTTMMTMTTMTMTTTTMMMTMTTTMTTTMMMTTTMTMTTTMTMTTTTTTTMMMMMTTTTMTMTTTMTMTTTTTTMTTTMTTMMMTMMTTMTMMMMTMTMTMTMMTTTTMTTTMTTTTMTTMTTMMTMTTMMTTTMTMTMTMTMMTTTTTTTTMMMMMTMMMTMMTTTMMMMTM 162 | MTMMMMTTMMTTMTMTTTTTTMTTMTMMTMTMMTTTMMTTMMMMTMMTMTMMMMMTTTMMMTTMMTMMMTTTMTTMTMTTMTTTMMMMTMTTMMTTMTTTMTMTTMMTTTMMMTMMMTTMTTMMTMTTTTTMMMTTMTMMTMMTMMTTMMTTMTMMMMMMTMMTMMTTTMTMTTMTMTTMTTMTTTTTTMMTMTMMMMTMMTMTMTTMMTMTMTTTTMTMMMMTTMMTMTTTTMMTTTTTTMMTMMTTMM 163 | TMMTMTMMMTMMTTTMTMTMTMMTMMMMTTMTTMMTMTMMTTMMTTMTMMMMTTTMTMTMMMMMMMTTTMTTMTMTTTMTTTTTTMMTTMTMMMMMMTMTTTTTMMMMMTTTMMMTMTMMMTTTMMMMTTMMTTMTTTTMMMTMTTTMTMMTTMTMMMMTMTTMMMMMTTTMMMMTTMTTTMTMMMTMTTMMTTMMMTTTMMMMMMMTTTMMTTMMMTTTTTTTTTMMMTMMTMTTMTMMTTTMTMTMTT 164 | MTTMMMTTMTTMTMMTMMTTTMTMTMMMTMTTMMTTTMMTMTMMMTMMTMTMTTMMTMMMTMMTMMTMMTTMMMMTTMTMMMTMMTMTTMTTTTTMMTMTMTTMMMMMTMTTTMTMTTMTMMMMMTMTTMMMTMMTMMTMMMTTTTMTMMTMTMMMMTMTTMMMMMTTMTMMMMMMTTMMTTMMTTTMTTTMTTMTTTMMMMMTTTMMTTTMTMTTMTMTTMMMMMTTTTTTMTTTTTTMMMTTTMMMTM 165 | MMMMTTTTMTTTMMMTMTTMTTTTMMTMTMMMMMMTTTTMMTMMMMTMMMMMMMMTMTMTMMMMTMMMTMMTTMTTTMTMTTTTMTTTMTTTMMTTTMMMTMMTMMTTTMTTTTMTTTMMMTTTMMMMTMTTMMMMTTTMTMTMTTTTMTTTTTMMMMMTMMTTMTTMMMTMTMMMMMMTTMTMTMTTTMMTTMTMMTTTMMTTMMMTMTMTTMMTTMTMMTTTTMTMMMTTMTTMTMTMTTTTMMTMMT 166 | MTMMMMMTMMMTTTTMMMTMTMMMTTTTMMTTTMMTTMMMTTMMTMTTTMTMMTMTTMTMTMTTTTTTTMTTMTMMMTMTTMTTMTTTMTTTMTMMTMTTTMMMMMTTMTMTMMTTTMMTTTMTTMTTMMMMMTMMTMTMMMTMMTTTMMMTMTMTMTMTMTMTMTMTMMTMMMTMTTTMTMMTTMTMMTTTMTTMTMTMMMTMMTMMMTTMTTMTMMMTTTMMTTMMTMMTTTMMMTTMMMMMTTTMTM 167 | MTTMMTMMMMMTTTMMMMTTTTMMTTMTTMMMMMTMMMMTTTTTMMMMMTMMMMTTTMMMTMTTMTMTMMTTTTMMTTTMMMMMMMMMMTMMMMTMMMMTMTMMMTTMTTTMMMTTTTMTTMMTMMTMMMTTMMMTTTTTMMTMTMMTMMMTTTMTTTMMTTTTTTTMMTMTTTMMTMTTTTTMTTTTTMTMMTMTMTTTTMMMTTMTMTTMTTMMTMTMMMMMMMTTMMTMTMMTMMMTTMTMTTTTTT 168 | MTTMTMMMTMMTMTTMTTMMTMTMTMMTTTTTMMMMMMTMMMMMTTMMMMTTTMMMMTTMMTTMTTTTMMTMMTTMTTTMTTTTMTTTTMTTMMMTTTMMMMTMTMTMTMTTMMMMTMMMMMMTMMTMMMMMTTTTTTTTMMMTMMMMMTMMMMTTTMTMTMMTTTMTTMMMTTMMTTTTTMTMTMMMMTMTMTTTTTTTMMMMTMTTMMMMTMTMTTMTMTMTTTMTMMMTTTTTTTTTTTMTMMTTMT 169 | TTTTMTMTTTMTTTMTTMMMTMMTTMMTTMMTMMTTTMTTMTMMMTMMMMTTMTTTTMMTMTTMMTTTMTMMMMTTTMMTTMTTTMMTTTTMMMMTTMTMMTMMTMTTMMMTTTTTTMTTMMMTMTMMTTTMTTTTTMMTTMMTTMTTTMMMTTMMMTTMMTTMMMTTTTMTMMMTMTMTMMMTTTMMMMMTTTMMTMMMTTMTMMMTMMMMTTTMTTTMMTMTMMMTMTMMTTTMTTMMTTMMMTMTMM 170 | MMTMMTMMTTMMMMMTTMTTTMMMMMMMTMMTMMTTTMTTMTTMMTMTTTTTTTTTTTMMMMMMMMMTMTTMMTMMMMTTTTMMTMMTMTMMTTMTMMMMMTMTTTTTTMTTMTMTTMTMMMTMMMMMMMTTTTTTTTTMMTMTMMMMMMTMTTMMMTTMTMMTMMMMTTTTTMTMMTMTTTTTMMTTMTMMTMTTTTTTMMTMMMTMMTTTMTTMTTMMTTTTTMMTTMTMMTTMTTMMTMMTMMMMTT 171 | MTTTMMTMTMMTMMMMMMTMTTTMTTTMMMTMMMTMMTMTMTMTTTMMMMMMTMTMMMTMTMTTMTMMMMTMTMTMTMTMTMMTMMMMMMTMMMTMMMMTTTMMTTTMMMMMMMTMMMMTTMMTMMTTMMTTMTTMTTTMMMMMMMTTMTMTTMMTMTMMTTTTMTMMTTTMTMTMMMTTTTTTMTMMMTTMTTMTTMTMMMTTMTMMTTMTTMMTTTMTTMTMTMMMMTMTTMTTMTTMTTTTTMMTMT 172 | TMTTTTTMMTMMTMMMTMTMTMMMTTTMTMTTMMTTMTTTTTTTMMTTMMMTTTTMTTMMTTMMMTMTMMTTMMTTMTTTMMMMTMMMTMTTTTMTTTMTTTTMMTMTTMMTMTMMTMTTTTMTMTMTMMTTMTTMMMMMMMTTTTMMTMTTTMTMMMTTTTTMTMMTTTMMTMTTMTMMMTMMMMMTMTTMTMMMTTMMMMMTMMMTMTTTMMMMTMMTMMMTMMMMMMTMTTMTMTTTMTMMTMTMMT 173 | TTMTMTMMMTMTMMMMTTMMTTMMTTTTMMTTTMMMTTMMMTTMMTTTTMMTMMMTMMTTTTTTTTMTMTMMTMMMTMTTMTMTTTMTMTTMTMMMTTTTMTMTMMTMMMMMTTMTMMTTMTMMTMTTTTMTMMMMTTMTMMTTMTTTTMMMMTMTTMMMTTTTMTMMMMTMTMTTTTTMMTTMTMMTMMTTTMMTMTTMTTTTTMTTMTTMTTTTMTTMTMTMMTMMTMMTMMTTTMMTMTTTTMMMMM 174 | MTTTTTMTTMTMMTTTTMMTTMTMTTTTMTMMMMMTMMMTTMMMMTMTMTMTTTTMMMMMTMMTTTMTTMTTTTTMTMMMTMMTMTMMMMMTMTMMTTMMMMTTMMMTTTMTMMTMTTTMTMTTMMMTMMMTTTTMTMMMMTMTMMMMTTMTTTMMTTTMTMMTTTTTTMTTTMTTTTMTTTMMTMTMTMMTTMMTTMMTTMTMTTMTMMMTTMTMMTMTTMMTTMTTMTTTMTMTMMMMMMTMTTMMMM 175 | MMMMTTMMTMMTTMMMTMMTTTTMMTTMMTMTMMTTTMTTTMTMTMTMTMMTMMTTTMTTMMMMMMTTTMMTTMTMTTMMMMTTMTTTTTMMTMTMMMMMMTTMMMTMMTMMMMMTMMMTMMMTMTTMTMTTMTMMTMTTMTTMMMTTMMTMTMMTMMMMMMMTMTTMMTTMTTMTMMMTTTTTTTTMTTTMTTMTTMTTTTTTTMTTMTTTTMMTTMMTMTTTTTTTTMMTTTTMTMTMMTTMTMMTMT 176 | TTTMTTMTTMMTTTMTMMMTTTTTTMTMTTTTMMMTTMMMTTTTMMTMTMTMTTMMTTMMTMTMMTMTTMTMMTTTMTMMMTTTTTMMMMTTTTTMMMTMTMTMMMMMTMMTTTTMMMTTMMMTMTMMTTMMMTMTMMTMMTMMMTTTMMMMTTMTMMMMTTTMTTMMMTTTMMTMTMMMTTMTMTMMMTMMTTTTTMTMMMTMMMMTTMTMTTMTMMMMTMTTTTTTTTMMMTMMMMMMTMMTMTMMTT 177 | TTTMMTTMTMTTMTMMTTTTMMMTMMTTMTMTTTMMMTTTTTMMTTMMTTMTTTMMMTTTMTMMTTTMMMTMMTMMMTTMMTMMMTTTTTTTTMMTTMTTMMMTTTMMMMTTMTTTMMMTMTMMMTTTMMMMMTMTMTTTMMMTMTMMMMTTMMMTMTTTTTMTTMTMTTTTMMMMTMMMMMMTMTMMTMTMTTTMMTTMMMMMTTMMMMTTTTMMTTTMMTMMMTMTMTTTTTMMTMMMTMMTMMTMMT 178 | TMTTTMTTMTTMMMMTTMTMTMTMTTMMTTTTMMMTTMTTMTTMMTTTTTTMTMTTTMMMMMMMMTMTMTMTMTTMTMMMTMMTMMTTMMTMTTTTMTMTTMMTTMMTTTMTMMMTTTMMMMMTTTMTTMTMMMMTMTTTMMTTTTTMMTTMMMTTTTMMTTMMMMMMTTTMTTTMTMMTTMTTMTTTTTMMTMMTTMMMTTMMMTMMMTTTMTMTTTMMTTMMTTTTTTTMTMMTMTTTMTMMMTTMTM 179 | TMTMMTMTMMTTTTTTMMMTTTTTMMMTMTMMMMTMTMTMMMTTMTMTMTMMMTMTMMTTTTTMTMMTTTMTMMMMTTMTMTTMMTTTTMTMMTTMTMMMMTTTTMMMTMMMMTTMMTMMMMTTTTTTTTMTMMTTMTMMTMMTTTMTTMMTMMMMTTMMTMTTTMMTTTTMTMTMMTMTTTTMTTTMTTTTMMMMMMTTMTMMTMTTMMTTMTTMMMMTTMTMTTMTMTTMMMTMTMMMTTMMMMMTTT 180 | TTTMMTTTMMMMMMTMTMTMMMTTMMMTMTMMTTMMTMTMMTMMTTTMTTTMTMMMTMTTMTMTTTTTMTMTTTMTMTMMMMMTMMTTTMMTMMTTTTMMTTTTMMMMMMMMMTTTTMMTTTMMMMTTMMMMTTMMTTMMMMMTMMMMMTMMMMTTTMTTTTTMTMTTMTMTTTTMTMTMMMMMMTMTTMTTTMTTMMTTTMMMTTTTTMTMTMTTMTTMMTTMMTTMTTMMMMTTTTTMMTMTTMMMTM 181 | MMMTTMTTTTTTMTMTMMTMTTMTTTTMMTTTTMMMTMMTMTMTMMTMTTTTMMMMTTMMTTMTMTTTMMTMMMTTMTTTMMTMTTTTMTMMMMTMMTTMMTMMMMMTTMTMMTMMTMTTTMMTMMMMMMTMMMMMTTTTMTMMMMTTTTMTTMMMMTMTMTTTMTMTMMTMMTTTTMTMTMTMMMTMTMMMTMTMTMMMTMMMTTMTMMMMMTTTTTTMMTMMTTTMTMMTTMMTMMTTTTMTMMMMTT 182 | MMMMTMMMTTTMMTMMMMTTMMTTMMTTMTMMTMTTMMTMTMMMTMTMMMTTMMMTMMMTMMTTTMTTMMMTTMMMTTMMTTMTMTTTMTMMTMMTMTMMTMTTTTTTTMMMTMTMMTMTMTMTMMTMTTMTMMMMMTMMMTMTTTMMTMTMMMMTMMMMTTMTMMMTTTTTTTTMMTMTMTTTMTMMTTTTTTMMMMMMMMTMMMMMMTTMTMMMMMMTTTMTMMMTMTTMMMTMTMMMMTMTMMTTMT 183 | TMTMMTMMMTMTTTMMMMMTTTTTTMTMTMTTMTMTTMTMMTTTTTTMTTMTTMMMMMMTTMMMMMTMTTMTMTTTTMMMMTTMMTMTMMMMTMTMMMTMMTTTTTTMTMMMMMMTMTTTMMTTTTMMTTTTMTTMTMMTMTTTTTMTMMTMMMMMMTMTMTTMMTMMMMTTTMMMMMTTMMMMTTTTTMTMTMMMMMTMTMMMTTMTTTMMTTTMMMMTMMMMMTTTTMTMTMMMTTTMMTTTMMTMMM 184 | TTMTMTMTTTMMTTTMTTMMMTTTMMTTMTMMTMMMTMMTTMTTTTMTTTTTTMTTTTTMTMTTTMMMTMMMMTTMMTMTTTMMMTMTMTTTMMMMTTMMTTTTMTMMTMTTTMMTTMTMTMTMMMMMMMTMMMTMTMMTTMTMMMMMMTMTMMTMTMMMMTMTTTMTMMTMMMMMMMMMTTTTTMMTMTTMMMTTMTTTTMTTTMTMTTTMMMMMMMTMTTMMTMTTMTTTTTTTTMTTMTMMMTTTTM 185 | TMMMTTMMMMTMTMMTTMMMTTTMMTMMMTTTTMTMMTMMTTTMTTTTMTTMTTTTMMTTTTTTTMMTMMMMMTTTMTTMTMMTMTTTTTTMTMTMMTMTMMTTMMTMMTMMMMTMTTMTTMMMMTTMMMMTMMTMMTMMMMTMTMTTTMMTMTTMMMTTTMMMTTTTMTTMMTMTTTMMTTTTMMTMMTMTMTMMTTMTMTTMMTMTTTTMMMTMTTMTMMMTTTMTTMTTTMMMTMTTMTTMMTTMTT 186 | MTMTTMTTTTTTTMMTTTTMMTTMMMTMMTTMTMMTMMMTTTMTMTMTTMTTTMTMMTMTTMTMMMMTMMTTTMMMMMMMMMTMMMMMMMTMTTTMTMTMMMMMTMTMTMTMTTMMMMTMMTTTMTTTMMTMMMMMTTMTTMTTTMTMMMMMTMMMTTMTMTMTMMTMTTTMTMMMTMMMMMTMMTMMMTMTMTTTTMTMMTMTMTTTTMMTTMTTMTMMMTTTMTTTMMMMMTTTMTMMTMMTTTTMMT 187 | TMMTTMTTMTMMTTTTTMMMMTMMMMMMTTMTTTMMTMTTMTMMMTTTTTMTTMTMTTMMTTTMMMMTMMTMMMTMTTTTMTMMTMMMMMMTTTTMMTTTTMTMTMMTMMTTMTTMMTTTTTMMMMMTTTTTMMMMMTMMMTTMTMTTMMTTTTMMMMMMMTTMMTTTTTMMTTTMMMTTTTTTMMMTTMMTTMMTMMTTTTMTMMTTTMTMTTTMMMMTTTTTMTTMMMMMTTTTMMTTTTMMTMMTTM 188 | TMMTTTTMTTMTMMMTTMTTMTTMTMMTMMTMMTTMMMTMMMMMTMMMTMMTTMTTTMTTTTTMMMTTMTMMMTMMTMTTMTTTMMMMMTTTTTMTTMTTMTTMMTMMMTTMMMTTTMTMTMMTTMMTMMTTMMTTTMTTMTMTMTTMMMTTTMTMTTMTMMMMMTTMTMTTTMMMMTMTMTMTTMTMTTTTTTMMTMTMTTMMTTTTMTMMMMMMTTTMTTTTMTTTMTMTTMMTTTMMTTMTMMMTTT 189 | MMMTMMMTTMTMMTTMMMTMTMMTMMMTMTMTTMTMMTMTTMTTTTMTMTTTTMTMMTTTMTMTMMTMMMMTMMMTTMMMTMTMTTMTMMMTMMMMMMMMMTMMTTTMMTMTMTTMMMMTMMMTTTMTMMMTTMTTTMTMMTTMTMMMTMTMMTTTMMMMTTMTTMMTTMTTTTMTMTTMMTMMMMTMMTMMMMMTMMTMMTTMTMTMMTTMTMMMTMMMTMMTTTTTMTMTMTMTMTMMTMTMMMMTMT 190 | TMMMMTMTTTTMTMMMTMTTMTTTMMMTTMTTMMMMMTTMTMTMTMMTMMMMTTTTTTTTTMTMMTMTTMMTTMTTTMMTTMMTTTTMMTMMMMTMMTMTMTMTTTTMTMMTTMMTMMMMMTTMTMTTTTTMMMMMTTMMMMMTTTTTMMTMTMTMMTMMMTTMTTTMMTTTTTTMMMMTMTMTTTMMTMTTTMTMTMTMMMMTMMTMTTMTTMMTTMMTTTMTTTTMTTMMMMMTTMTMTTMMMMTTTM 191 | TTMMMMMTMTTTMMMMMMTMTMTTMTTTMMMTTTTMMTMMMTMMMMTTTMTTMMTMMMMMMTMTTMMTMTMTMTMMTMMTMMTMMTTMMMTMMTTMMTMMMMMMTMTMMTTTMTTMTTTTMTMMMMTTMMTMTTTTTTTMMTTMTTTMMTMTMTMMTTMTMMTTTMTTMTMTMTTMTMMMTMTMTMTTTMTTMMMTMTMMMTMMTTMMMTTTTTTTMMMTTMMMMTTMMTTMMTMMTMTTTMMTMTMMTT 192 | MMMMMTTTMMTMMMTMTTMTMTMMMMMMTMMMTTMMMMMMMTMTTMMTMMTTMTTMTTMTTTTTTMMTMTMMTMMTMTTTTMMMMMMMMMTTTTMTMMTTMTTTMTMTTTTTTTTMTMTMMMTTTMTTTTTTMMTTMTMTMTMTMTMTMMMMMMMTTMTTTTMTTMTTMTMTMMTMTTMMTMMTTTTTMMTTTTMMMTMTMTTTMMMTTMTTTTMMTMMMTTMMTMMMMTTMTTTTTTMTMMMTMMMTTM 193 | MMTTMTMMMMTMMTTMTTTTTTMTMTMTMTMTMMMTMMMTTTMMTMMTMTTMTMMMTTTTTMMTTMTMMMTMMMMMMTTMMMTTTMMMTTTMTMMMMTMTTMTMTTMMTMTTMMTTTTTMMTMTTTMMMTTTMMTTTMTMTTTMTMTMTTMTTTTTTTTTMMMTMTTTMTMMTTTTMMTMMMMTMMTMMMTMMMMMMTTMMTMTTMMTTMMTMMMTMTTMMMMTTTTMTTMTMMMTTTTTMTTTTTMTMT 194 | TMMMTTTMTMTMMTTTTMTMTMMTMTMTMTTTMTTTMMMTMTMMMMMTTTMMTTMTMTMTMMTTTMMTMTMMMMMMTTMMMTTMTMMMTMMMMMMMTMMMTMMMTTTTTMTTMTTTMTTMTMTTTTMMMTMMTMMTTMTTTMTMTTTMMMMTMTTMMTMMMTTTMMTTMTMTTTTMMTMTMTTTMTMMMMTTTMMTTTMTTTTMMMMMMTTTMMTTTTTMTMMTMTTMMTTMMMTTMTTMMTMTTMMMMM 195 | TMTMMTTTTTTMTTMTMMMMMMTTMMMTMTTTTMMTMTMMTTTMTMTMMTMTMMTMMMMTTTMMTMTTMTMTTTMMMTTMMTMTTTTTTMMTMTTTTTMMMTTMMTMTTTTTMMMMTMTTMMTMMTTMTTMMMTTTTTMTTMMTMTTMMMMTTMMMMTTMTMTMTMTTTMTTTMTTMMMMTTTMTTMMTTTTTMMTTTMTTTMMMMTTMMMTMMTTMTMTMMTTMMTMMTMTMMMTMTTTMMTTMTTMMT 196 | TMMMTTTMTMMTMMTTTMTMMMTTMTMTTMTMTTTTMTTTTTTMTTTTMTMMTMMTMTMMMTTMTMMMMTTMMTTMMTTMMMMMTTMTTMTMMTMTTMTMMMTMTTMMMMTMTMMTTMMMMTTMMMMMTTMTTTMMTMMTTTTMTTMTTTTTTMTMTTTMMMMMTMTMTMMTMMMTMTMTMMMTTMMMTMMTMMMTMTTMTMTTTTTTTTMTMTMMMMMMTTMMMMMTMTMTTTTMMTTTMMMTMMMTTM 197 | MMMMTMTMTMTTMMMTMTTMMMMTTTTMMTMMMMMTMMMMTTTMMTTMMTMTMTMTMTTMMTMTMMMMTTTTMTMMTMMTMTTTTTTMTMTMMTMMTMMMMMMTTMMTTMMTTMTTMMMTTMMMMMMMTMTMTTTTTTTMMTMTTMMTMTMTTTMMTMMMMTMMMMTTMTMMTTMMTTMTTMTMTMTMTTTTMTMTTTTMTTMMMTMTMMMMMTTMMTMMMTMTTTMMMTTTTMMMTMTMTTMTTMTMMT 198 | TMMMMMMMTMMMTTTTTTTTTMMMMTTMMMTTMMTTTTMMMTTTTTMMTTMMMMTTTMMMTMMMMMTMMTTTTMMTTMMMTMMTMTTTTTMTTMTTMTMMTMMTTMTTTTTMMTTTMMMTMTMMMTMMMTTMTMMMTMMMMTMMMTMMMMTMMTMMMTMTMMMMMMTTMMTMMTMTTTTTMTMMMMTTMMMMTMMTMMTMMMMMTTTTTTTTMTMTTMMTMTMMMMMTTTMMMTTMTTMMMTTTTMTTMT 199 | TMTTMTTMTTMMMMMTTTMTMTTMTTMTTMMTTTTTTTMTMTMTMTMMTMTMTTTTTTMTMTTMMTTTMTTTMMTTTMTTMTTTTMTMTTMTTTTTTMMMMTMMTTMTMTMTTMTMMMMMTMTTMMMMTTMTTMTMMTMTTTMMTMMTTTTMMTTMMMTMMTMTTTTTMTMMTTMMMMTMMMMTMTTTTMMTTTTMTMMMTMTTTTTMTTTTMTMMMTMMTTTMTTTMMTMMTMTMMMTMTMMTMTTMMT 200 | MMMTMTMMTMMTMTMTTTTTTTTTTTTTTTTMMMMTMMTTTTMTTTTTMMMMMMMMTMTTMMTTTTTMTMMTTMMTTTMTTTMTTMTTTMTTTMMMMMMTMTTMTTMMMMTTMMMMTMMTMMMMMMTMTTMMTTTTTTTMMTTMMMMMTMMMMTMTMTTMMTMTTMTTTTTMTTMTMMTMTTMMMTMTMMTTTTTMMTMMTTTMTMTMTMMMMTTTTMTMTTTTTMMMTTTTMTMMMMTTTMMTTTMMTM 201 | MTTTTTTMTMTTMMMTTMTMTTMTMMMTMTTTTTMTMMMMTMMTTTTTMTTTMMTMTTMTTMMTMMTTMTMMTTMTMTTTTTTTTMMTTTTMTMMMMMTMMTTMMMMMTMTTTTTTTMTTTMTMTTMTTMTMMTTTTMTTTTMTMMMTTMMMTMTMMMTMMTMTMTTMMTTTTMTTMMTMTMTTMTTTTTTTTTMMMMTMTMTMTMTMMTTMTMTTTMMTTMMMTTTMTTTMMTTMMMTMTMTMMMMMMT 202 | -------------------------------------------------------------------------------- /inputDataSets/small.in: -------------------------------------------------------------------------------- 1 | 6 7 1 5 2 | TMMMTTT 3 | MMMMTMM 4 | TTMTTMT 5 | TMMTMMM 6 | TTTTTTM 7 | TTTTTTM 8 | -------------------------------------------------------------------------------- /outputDataSet/example.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 1 2 2 2 3 | 1 0 1 1 4 | 1 3 1 4 5 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | 5 | com.google.hashcode 6 | pizza 7 | 0.0.2 8 | jar 9 | 10 | pizza 11 | http://maven.apache.org 12 | an assignment for google hash code 2017 competition 13 | 14 | 15 | UTF-8 16 | 1.8 17 | 1.8 18 | 19 | 20 | 21 | 22 | junit 23 | junit 24 | 4.12 25 | test 26 | 27 | 28 | org.slf4j 29 | slf4j-api 30 | 1.7.21 31 | 32 | 33 | ch.qos.logback 34 | logback-core 35 | 1.1.7 36 | 37 | 38 | ch.qos.logback 39 | logback-classic 40 | 1.1.7 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/App.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode; 2 | 3 | import com.google.hashcode.entity.Pizza; 4 | import com.google.hashcode.entity.Slice; 5 | import com.google.hashcode.entity.Step; 6 | import com.google.hashcode.utils.IoUtils; 7 | import com.google.hashcode.utils.Profiler; 8 | import org.slf4j.Logger; 9 | import org.slf4j.LoggerFactory; 10 | 11 | import java.io.File; 12 | import java.io.IOException; 13 | import java.util.ArrayList; 14 | import java.util.List; 15 | import java.util.Map; 16 | 17 | import static com.google.hashcode.utils.FilesPaths.*; 18 | import static com.google.hashcode.utils.SlicingMethods.*; 19 | 20 | 21 | public class App { 22 | private static final Logger LOGGER = LoggerFactory.getLogger(App.class); 23 | 24 | public static void main(String[] args) throws IOException { 25 | slicePizza(EXAMPLE_INPUT_FILE_PATH, OUTPUT_DATA_SET_EXAMPLE_TXT); 26 | slicePizza(SMALL_INPUT_FILE_PATH, OUTPUT_DATA_SET_SMALL_TXT); 27 | slicePizza(MEDIUM_INPUT_FILE_PATH, OUTPUT_DATA_SET_MEDIUM_TXT); 28 | //takes to much time ~ 20 hours using intel -I5 29 | //slicePizza(BIG_INPUT_FILE_PATH, OUTPUT_DATA_SET_BIG_TXT); 30 | } 31 | 32 | /** 33 | * Performs a pizza slicing 34 | * 35 | * @param inputFile given input pizza file 36 | * @param outputFile a file slicing results 37 | * @throws IOException cant parse a pizza file 38 | */ 39 | public static void slicePizza(String inputFile, String outputFile) throws IOException { 40 | Profiler profiler = new Profiler(); 41 | List startPositions; 42 | List output = new ArrayList<>(); 43 | Pizza pizza = new Pizza(new File(inputFile), IoUtils.parsePizza(inputFile), IoUtils.parseSliceInstructions(inputFile)); 44 | //get start positions 45 | startPositions = cutAllStartPositions(pizza); 46 | //get All steps 47 | Map> availableSteps = getAvailableSteps(pizza, startPositions, output); 48 | while (!availableSteps.values().stream().allMatch(List::isEmpty)) { 49 | Step step = selectStep(availableSteps); 50 | performStep(pizza, step, startPositions, output); 51 | availableSteps = getAvailableSteps(pizza, startPositions, output); 52 | LOGGER.debug("OUTPUT AFTER A STEP: " 53 | + "\n " + output); 54 | LOGGER.debug("start positions cells number: " + startPositions.stream() 55 | .map(slice -> slice.cells.size()) 56 | .reduce(0, (integer, integer2) -> integer + integer2) 57 | ); 58 | } 59 | IoUtils.writeToFile(outputFile, IoUtils.parseSlices(output)); 60 | LOGGER.info("FINISHED for " + inputFile + "!!!!!"); 61 | LOGGER.info("sliced cells number: " + output.stream() 62 | .map(slice -> slice.cells.size()) 63 | .reduce(0, (integer, integer2) -> integer + integer2)); 64 | LOGGER.info(profiler.measure(inputFile + " execution time: ")); 65 | } 66 | 67 | } 68 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/Cell.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import java.util.Objects; 4 | 5 | /** 6 | * Represents a pizza cell with it coordinates. There is no getters/setters for simplicity 7 | * 8 | * @author Grigoriy Lyashenko (Grog). 9 | */ 10 | public class Cell { 11 | public int y; 12 | public int x; 13 | public Ingredient ingredient; 14 | 15 | public Cell(int y, int x, Ingredient ingredient) { 16 | this.y = y; 17 | this.x = x; 18 | this.ingredient = ingredient; 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return ingredient.toString(); 24 | } 25 | 26 | @Override 27 | public boolean equals(Object o) { 28 | if (this == o) return true; 29 | if (!(o instanceof Cell)) return false; 30 | Cell cell = (Cell) o; 31 | return this.x == cell.x && 32 | this.y == cell.y && 33 | this.ingredient == cell.ingredient; 34 | } 35 | 36 | @Override 37 | public int hashCode() { 38 | return Objects.hash(x, y, ingredient); 39 | } 40 | 41 | public int getX() { 42 | return x; 43 | } 44 | 45 | public int getY() { 46 | return y; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/Ingredient.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | /** 4 | * Represents possible pizza cell types 5 | * 6 | * @author Grigoriy Lyashenko (Grog). 7 | */ 8 | public enum Ingredient { 9 | MUSHROOM("M"), TOMATO("T"); 10 | private final String type; 11 | 12 | Ingredient(final String type) { 13 | this.type = type; 14 | } 15 | 16 | @Override 17 | public String toString() { 18 | return type; 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/Pizza.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import java.io.File; 4 | import java.util.Comparator; 5 | import java.util.List; 6 | import java.util.Optional; 7 | 8 | /** 9 | * Represents an immutable pizza 10 | * 11 | * @author Grigoriy Lyashenko (Grog). 12 | */ 13 | public class Pizza { 14 | 15 | private final File input; 16 | private final SliceInstruction sliceInstruction; 17 | private List cells; 18 | 19 | public Pizza(File input, List cells, SliceInstruction sliceInstruction) { 20 | this.input = input; 21 | this.cells = cells; 22 | this.sliceInstruction = sliceInstruction; 23 | } 24 | 25 | public File getInput() { 26 | return input; 27 | } 28 | 29 | public List getCells() { 30 | return cells; 31 | } 32 | 33 | public void setCells(List cells) { 34 | this.cells = cells; 35 | } 36 | 37 | /** 38 | * Coordinates are like in a 2D array 39 | * 40 | * @param y - row number, 0..max row number 41 | * @param x - column number,0..max column number 42 | * @return a pizza cell with specified coordinated 43 | */ 44 | public Optional getCell(int y, int x) { 45 | return cells.stream().filter(cell -> cell.x == x && cell.y == y).findFirst(); 46 | } 47 | 48 | public SliceInstruction getSliceInstruction() { 49 | return sliceInstruction; 50 | } 51 | 52 | @Override 53 | public String toString() { 54 | return input.toString() 55 | + ("\n" + sliceInstruction.toString() 56 | + "\n" + outputCellsArray()).trim(); 57 | } 58 | 59 | /** 60 | * Indicates does this pizza contains each slice's cell 61 | * 62 | * @param slice given slice 63 | * @return true if the pizza contains the slice 64 | */ 65 | public boolean containsCells(Slice slice) { 66 | return slice.cells.stream().allMatch(this.cells::contains); 67 | } 68 | 69 | private String outputCellsArray() { 70 | if (!cells.isEmpty() && cells.size() < 100) { 71 | StringBuilder stringBuilder = new StringBuilder(); 72 | int columnsCount = cells.stream().max(Comparator.comparingInt(Cell::getX)).get().getX(); 73 | int rowsCount = cells.stream().max(Comparator.comparingInt(Cell::getY)).get().getY(); 74 | //output columns coordinates 75 | stringBuilder.append(" "); 76 | for (int column = 0; column < columnsCount + 1; column++) { 77 | stringBuilder.append(" ").append(column); 78 | } 79 | stringBuilder.append("\n"); 80 | for (int row = 0; row < rowsCount + 1; row++) { 81 | //output rows coordinates 82 | stringBuilder.append(row).append(" "); 83 | for (int column = 0; column < columnsCount + 1; column++) { 84 | if (this.getCell(row, column).isPresent()) { 85 | stringBuilder.append(this.getCell(row, column).get().toString()).append(" "); 86 | } else { 87 | stringBuilder.append(" ").append(" "); 88 | } 89 | } 90 | stringBuilder.append("\n"); 91 | } 92 | return stringBuilder.toString(); 93 | } else { 94 | return "pizza size is:" + cells.size(); 95 | } 96 | 97 | } 98 | 99 | 100 | } 101 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/Slice.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import java.util.*; 7 | import java.util.stream.Collectors; 8 | 9 | /** 10 | * A rectangle piece of a pizza 11 | * 12 | * @author Grigoriy Lyashenko (Grog). 13 | */ 14 | public class Slice { 15 | private static final Logger LOGGER = LoggerFactory.getLogger(Slice.class); 16 | 17 | public List cells = new ArrayList<>(); 18 | 19 | public Slice() { 20 | } 21 | 22 | public Slice(Cell... cell) { 23 | this.cells = new ArrayList<>(Arrays.asList(cell)); 24 | } 25 | 26 | public Slice(List cells) { 27 | this.cells = cells; 28 | } 29 | 30 | @Override 31 | public boolean equals(Object o) { 32 | if (this == o) return true; 33 | if (!(o instanceof Slice)) return false; 34 | Slice slice = (Slice) o; 35 | return Objects.equals(cells, slice.cells); 36 | } 37 | 38 | @Override 39 | public int hashCode() { 40 | return Objects.hash(cells); 41 | } 42 | 43 | public int minX() { 44 | return Collections.min(cells, Comparator.comparingInt(Cell::getX)).x; 45 | } 46 | 47 | public int minY() { 48 | return Collections.min(cells, Comparator.comparingInt(Cell::getY)).y; 49 | } 50 | 51 | public int maxX() { 52 | return Collections.max(cells, Comparator.comparingInt(Cell::getX)).x; 53 | } 54 | 55 | public int maxY() { 56 | return Collections.max(cells, Comparator.comparingInt(Cell::getY)).y; 57 | } 58 | 59 | 60 | /** 61 | * Coordinates are like in a 2D array 62 | * 63 | * @param y - row number, 0..max row number 64 | * @param x - column number,0..max column number 65 | * @return a pizza cell with specified coordinated 66 | */ 67 | public Optional getCell(int y, int x) { 68 | return cells.stream().filter(cell -> cell.x == x && cell.y == y).findFirst(); 69 | } 70 | 71 | @Override 72 | public String toString() { 73 | StringBuilder stringBuilder = new StringBuilder(); 74 | stringBuilder.append("slice : \n"); 75 | if (maxX() + maxY() < 20) { //output coordinates 76 | int columnsCount = cells.stream().max(Comparator.comparingInt(Cell::getX)).get().getX(); 77 | int rowsCount = cells.stream().max(Comparator.comparingInt(Cell::getY)).get().getY(); 78 | //output columns coordinates 79 | stringBuilder.append(" "); 80 | for (int column = 0; column < columnsCount + 1; column++) { 81 | stringBuilder.append(" ").append(column); 82 | } 83 | stringBuilder.append("\n"); 84 | for (int row = 0; row < rowsCount + 1; row++) { 85 | //output rows coordinates 86 | stringBuilder.append(row).append(" "); 87 | for (int column = 0; column < columnsCount + 1; column++) { 88 | if (this.getCell(row, column).isPresent()) { 89 | stringBuilder.append(this.getCell(row, column).get().toString()).append(" "); 90 | } else { 91 | stringBuilder.append(" ").append(" "); 92 | } 93 | } 94 | stringBuilder.append("\n"); 95 | } 96 | } else stringBuilder.append("\nsize: ").append(cells.size()); 97 | return stringBuilder.toString().trim(); 98 | } 99 | 100 | /** 101 | * check if slice valid for current pizza. 102 | * 103 | * @param pizza 104 | * @return 105 | */ 106 | public boolean isValid(Pizza pizza) { 107 | //TODO check rectangularity 108 | int mushroomsNumber = this.cells.stream() 109 | .filter(cell -> cell.ingredient.equals(Ingredient.MUSHROOM)) 110 | .collect(Collectors.toList()) 111 | .size(); 112 | int tomatoesNumber = this.cells.stream() 113 | .filter(cell -> cell.ingredient.equals(Ingredient.TOMATO)) 114 | .collect(Collectors.toList()) 115 | .size(); 116 | boolean isPassedSliceInstructions = this.cells.size() <= pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice() 117 | && tomatoesNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice() 118 | && mushroomsNumber >= pizza.getSliceInstruction().getMinNumberOfIngredientPerSlice(); 119 | LOGGER.debug("\n" + pizza.getSliceInstruction() + 120 | "\nSlice :" + this + 121 | "\npassed validation: " + isPassedSliceInstructions); 122 | return isPassedSliceInstructions; 123 | } 124 | 125 | //region generate steps 126 | 127 | public Step generateStepAbove(Pizza pizza) { 128 | Slice delta = new Slice(); 129 | for (int x = this.minX(); x <= this.maxX(); x++) { 130 | //try to get a cell 131 | Optional cell = pizza.getCell(this.minY() - 1, x); 132 | if (cell.isPresent()) { 133 | delta.cells.add(cell.get()); 134 | } else { 135 | LOGGER.debug("cant perform step left !"); 136 | return null; 137 | } 138 | } 139 | LOGGER.debug("generateStepLeft" 140 | + "\nstep left delta: " + delta.toString()); 141 | Step step = new Step(this, delta); 142 | if (step.isValid(pizza)) { 143 | return step; 144 | } else { 145 | LOGGER.debug("step is invalid !"); 146 | return null; 147 | } 148 | } 149 | 150 | public Step generateStepBelow(Pizza pizza) { 151 | Slice delta = new Slice(); 152 | for (int x = this.minX(); x <= this.maxX(); x++) { 153 | //try to get a cell 154 | Optional cell = pizza.getCell(this.maxY() + 1, x); 155 | if (cell.isPresent()) { 156 | delta.cells.add(cell.get()); 157 | } else { 158 | LOGGER.debug("cant perform step left !"); 159 | return null; 160 | } 161 | } 162 | LOGGER.debug("generateStepLeft" 163 | + "\nstep left delta: " + delta.toString()); 164 | Step step = new Step(this, delta); 165 | if (step.isValid(pizza)) { 166 | return step; 167 | } else { 168 | LOGGER.debug("step is invalid !"); 169 | return null; 170 | } 171 | } 172 | 173 | public Step generateStepLeft(Pizza pizza) { 174 | Slice delta = new Slice(); 175 | for (int y = this.minY(); y <= this.maxY(); y++) { 176 | //try to get a cell 177 | Optional cell = pizza.getCell(y, minX() - 1); 178 | if (cell.isPresent()) { 179 | delta.cells.add(cell.get()); 180 | } else { 181 | LOGGER.debug("cant perform step left !"); 182 | return null; 183 | } 184 | } 185 | LOGGER.debug("generateStepLeft" 186 | + "\nstep left delta: " + delta.toString()); 187 | Step step = new Step(this, delta); 188 | if (step.isValid(pizza)) { 189 | return step; 190 | } else { 191 | LOGGER.debug("step is invalid !"); 192 | return null; 193 | } 194 | } 195 | 196 | public Step generateStepRight(Pizza pizza) { 197 | Slice delta = new Slice(); 198 | for (int y = this.minY(); y <= this.maxY(); y++) { 199 | //try to get a cell 200 | Optional cell = pizza.getCell(y, maxX() + 1); 201 | if (cell.isPresent()) { 202 | delta.cells.add(cell.get()); 203 | } else { 204 | LOGGER.debug("cant perform step right !"); 205 | return null; 206 | } 207 | } 208 | LOGGER.debug("generateStepLeft" 209 | + "\nstep left delta: " + delta.toString()); 210 | Step step = new Step(this, delta); 211 | if (step.isValid(pizza)) { 212 | return step; 213 | } else { 214 | LOGGER.debug("step is invalid !"); 215 | return null; 216 | } 217 | } 218 | //endregion 219 | 220 | } 221 | 222 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/SliceInstruction.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | /** 4 | * Instructions how to slice a pizza 5 | * 6 | * @author Grigoriy Lyashenko (Grog). 7 | */ 8 | public class SliceInstruction { 9 | private final Integer minNumberOfIngredientPerSlice; 10 | private final Integer maxNumberOfCellsPerSlice; 11 | 12 | public SliceInstruction(Integer minNumberOfIngredientPerSlice, Integer maxNumberOfIngredientPerSlice) { 13 | this.minNumberOfIngredientPerSlice = minNumberOfIngredientPerSlice; 14 | this.maxNumberOfCellsPerSlice = maxNumberOfIngredientPerSlice; 15 | } 16 | 17 | public Integer getMinNumberOfIngredientPerSlice() { 18 | return minNumberOfIngredientPerSlice; 19 | } 20 | 21 | public Integer getMaxNumberOfCellsPerSlice() { 22 | return maxNumberOfCellsPerSlice; 23 | } 24 | 25 | @Override 26 | public String toString() { 27 | return "SliceInstructions: \n" + 28 | "min " + minNumberOfIngredientPerSlice + " ingredient per slice, " + 29 | "max " + maxNumberOfCellsPerSlice + " cells per slice "; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/entity/Step.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import java.util.ArrayList; 4 | 5 | /** 6 | * Step as an entity is a slice tha can be added to a particular slice inside a particular pizza, considering 7 | * pizza's slice instructions 8 | * 9 | * @author Grigoriy Lyashenko (Grog). 10 | */ 11 | public class Step { 12 | 13 | public Slice startPosition; 14 | public Slice delta; 15 | 16 | public Step(Slice startPosition, Slice delta) { 17 | super(); 18 | this.startPosition = startPosition; 19 | this.delta = delta; 20 | } 21 | 22 | public boolean isValid(Pizza pizza) { 23 | Slice slice = new Slice(new ArrayList<>(startPosition.cells)); 24 | slice.cells.addAll(delta.cells); 25 | return slice.isValid(pizza) || 26 | slice.cells.size() < pizza.getSliceInstruction().getMaxNumberOfCellsPerSlice(); 27 | } 28 | 29 | public int size() { 30 | return startPosition.cells.size() + delta.cells.size(); 31 | } 32 | 33 | @Override 34 | public String toString() { 35 | return "\nStep{" + 36 | "\nstartPosition=" + startPosition.toString() + 37 | "\ndelta=" + delta.toString() + 38 | "\n}"; 39 | } 40 | 41 | 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/utils/FilesPaths.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | /** 4 | * Contains common files to perform input-output 5 | * 6 | * @author Grigoriy Lyashenko (Grog). 7 | */ 8 | public abstract class FilesPaths { 9 | public static final String EXAMPLE_INPUT_FILE_PATH = "inputDataSets/example.in"; 10 | public static final String SMALL_INPUT_FILE_PATH = "inputDataSets/small.in"; 11 | public static final String MEDIUM_INPUT_FILE_PATH = "inputDataSets/medium.in"; 12 | public static final String BIG_INPUT_FILE_PATH = "inputDataSets/big.in"; 13 | 14 | 15 | public static final String OUTPUT_DATA_SET_EXAMPLE_TXT = "outputDataSet/example.txt"; 16 | public static final String OUTPUT_DATA_SET_SMALL_TXT = "outputDataSet/small.txt"; 17 | public static final String OUTPUT_DATA_SET_BIG_TXT = "outputDataSet/big.txt"; 18 | public static final String OUTPUT_DATA_SET_MEDIUM_TXT = "outputDataSet/medium.txt"; 19 | 20 | private FilesPaths() { 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/utils/IoUtils.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import com.google.hashcode.entity.Cell; 4 | import com.google.hashcode.entity.Ingredient; 5 | import com.google.hashcode.entity.Slice; 6 | import com.google.hashcode.entity.SliceInstruction; 7 | 8 | import java.io.BufferedReader; 9 | import java.io.FileReader; 10 | import java.io.IOException; 11 | import java.io.PrintWriter; 12 | import java.nio.file.Files; 13 | import java.nio.file.Paths; 14 | import java.util.ArrayList; 15 | import java.util.Comparator; 16 | import java.util.Formatter; 17 | import java.util.List; 18 | 19 | /** 20 | * @author Grigoriy Lyashenko (Grog). 21 | * @author github.com/VadimKlindukhov skype: kv_vadim 22 | */ 23 | public class IoUtils { 24 | private IoUtils() { 25 | } 26 | 27 | /** 28 | * Parses given input file to a 2d pizza cells array 29 | * 30 | * @param file input file 31 | * @return 2d array representing a pizza 32 | * @throws IOException parsing fail 33 | */ 34 | public static List parsePizza(String file) throws IOException { 35 | try (FileReader fileReader = new FileReader(file)) { 36 | BufferedReader br = new BufferedReader(fileReader); 37 | //skip a line with slice instructions 38 | br.readLine(); 39 | //declare a pizza cells array 40 | List cells = new ArrayList<>(); 41 | int row = 0; 42 | String fileLine; 43 | while ((fileLine = br.readLine()) != null) { 44 | for (int column = 0; column < fileLine.length(); column++) { 45 | Character literal = fileLine.charAt(column); 46 | if (literal.toString().equals(Ingredient.TOMATO.toString())) { 47 | cells.add(new Cell(row, column, Ingredient.TOMATO)); 48 | } else if (literal.toString().equals(Ingredient.MUSHROOM.toString())) { 49 | cells.add(new Cell(row, column, Ingredient.MUSHROOM)); 50 | } 51 | } 52 | row++; 53 | } 54 | return cells; 55 | } 56 | } 57 | 58 | /** 59 | * Produces SliceInstructions based on given input data set 60 | * 61 | * @param file input data set 62 | * @return slice instructions 63 | * @throws IOException file reading error 64 | */ 65 | public static SliceInstruction parseSliceInstructions(String file) throws IOException { 66 | try (FileReader fileReader = new FileReader(file)) { 67 | BufferedReader br = new BufferedReader(fileReader); 68 | String[] headerTokens = br.readLine().split(" "); 69 | int minNumberOfIngredientPerSlice = Integer.parseInt(headerTokens[2]); 70 | int maxNumberOfCellsPerSlice = Integer.parseInt(headerTokens[3]); 71 | return new SliceInstruction(minNumberOfIngredientPerSlice, maxNumberOfCellsPerSlice); 72 | } 73 | } 74 | 75 | /** 76 | * Formats data from list of slices to the required output format 77 | * 78 | * @param list inner representation of pizza 79 | * @return String that contains output data 80 | */ 81 | public static String parseSlices(List list) { 82 | Comparator cellComparator = (Cell c1, Cell c2) -> { 83 | if (c1.x != c2.x) { 84 | return Integer.compare(c1.x, c2.x); 85 | } else 86 | return Integer.compare(c1.y, c2.y); 87 | }; 88 | StringBuilder sb = new StringBuilder(); 89 | Formatter textFormatter = new Formatter(sb); 90 | textFormatter.format("%d%n", list.size()); 91 | Cell min, max; 92 | for (Slice slice : list) { 93 | min = slice.cells.stream().min(cellComparator).get(); 94 | max = slice.cells.stream().max(cellComparator).get(); 95 | textFormatter.format("%d %d %d %d%n", min.y, min.x, max.y, max.x); 96 | } 97 | textFormatter.close(); 98 | return sb.toString().trim(); 99 | } 100 | 101 | public static void writeToFile(String fileName, String outputDate) throws IOException { 102 | try (PrintWriter out = new PrintWriter(fileName)) { 103 | out.println(outputDate); 104 | } 105 | } 106 | 107 | public static String readFromFile(String fileName) throws IOException { 108 | List lines = Files.readAllLines(Paths.get(fileName)); 109 | StringBuilder stringBuilder = new StringBuilder(); 110 | lines.forEach( 111 | line -> stringBuilder.append(line).append("\n") 112 | ); 113 | return stringBuilder.toString(); 114 | } 115 | } 116 | 117 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/utils/Profiler.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import java.time.Duration; 4 | import java.time.Instant; 5 | 6 | /** 7 | * Simplest profiler 8 | * 9 | * @author Grigoriy Lyashenko (Grog). 10 | */ 11 | public class Profiler { 12 | 13 | private Instant start; 14 | 15 | public Profiler() { 16 | this.start = Instant.now(); 17 | } 18 | 19 | /** 20 | * Calculated difference between start and finish time and output its String representation 21 | * 22 | * @param message optional message before performance output 23 | */ 24 | public String measure(String message) { 25 | Instant end = Instant.now(); 26 | return message + Duration.between(start, end).toMillis() + "ms"; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/utils/SlicingMethods.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import com.google.hashcode.entity.*; 4 | import org.slf4j.Logger; 5 | import org.slf4j.LoggerFactory; 6 | 7 | import java.util.*; 8 | import java.util.stream.Collectors; 9 | 10 | public abstract class SlicingMethods { 11 | private static final Logger LOGGER = LoggerFactory.getLogger(SlicingMethods.class); 12 | 13 | private SlicingMethods() { 14 | } 15 | 16 | /** 17 | * Find all available steps for a given start positions, considering:
18 | * * slice instructions for a given pizza
19 | * * start position + slices should form a rectangle
20 | *

21 | * If there is no steps fo a given start position:
22 | * 1. A start position is valid as a slice and can be cutted -> move it to output slices
23 | * 2. A start position ISN'T valid as a slice -> remove it from startPositions and add all it cells back to a pizza 24 | * 25 | * @param pizza given pizza 26 | * @param startPositions given start positions in the pizza(a slice with cells number 1..max slice cells number) 27 | * @param output list of valid and cutted slices 28 | * @return available steps 29 | */ 30 | public static Map> getAvailableSteps(Pizza pizza, List startPositions, List output) { 31 | Map> groupedByAStartPositionSteps = new HashMap<>(); 32 | Iterator iterator; 33 | //optimization for big arrays 34 | if (startPositions.size() > 1_000) { 35 | List startPositionsSubset = startPositions.subList(0, 20); 36 | iterator = startPositionsSubset.iterator(); 37 | } 38 | //iterate over all the start positions 39 | else { 40 | iterator = startPositions.iterator(); 41 | } 42 | while (iterator.hasNext()) { 43 | Slice startPosition = (Slice) iterator.next(); 44 | 45 | List steps = new ArrayList<>(); 46 | Step stepLeft = startPosition.generateStepLeft(pizza); 47 | Step stepRight = startPosition.generateStepRight(pizza); 48 | Step stepAbove = startPosition.generateStepAbove(pizza); 49 | Step stepBelow = startPosition.generateStepBelow(pizza); 50 | 51 | steps.add(stepRight); 52 | steps.add(stepLeft); 53 | steps.add(stepBelow); 54 | steps.add(stepAbove); 55 | steps = steps.stream() 56 | .filter(Objects::nonNull) 57 | .collect(Collectors.toList()); 58 | LOGGER.debug("There is no steps fo a given start position !"); 59 | if (steps.isEmpty()) { 60 | LOGGER.debug("A start position is valid as a slice and can be cutted ->" + 61 | " move it to output slices"); 62 | if (startPosition.isValid(pizza)) { 63 | output.add(startPosition); 64 | iterator.remove(); 65 | } else { 66 | LOGGER.debug("A start position ISN'T valid as a slice -> " + 67 | "remove it from startPositions and add all it cells"); 68 | pizza.getCells().addAll(startPosition.cells); 69 | iterator.remove(); 70 | } 71 | } else { 72 | groupedByAStartPositionSteps.put(startPosition, steps); 73 | } 74 | } 75 | LOGGER.debug("available steps for" + 76 | "\npizza: " + pizza 77 | + "\nsteps: " + groupedByAStartPositionSteps); 78 | return groupedByAStartPositionSteps; 79 | } 80 | 81 | /** 82 | * Performs a step with a minimal cells delta number and executes it (cut it from a pizza, and add to a slice) 83 | * 84 | * @param pizza given pizza 85 | * @param step step to perform 86 | * @param startPositions given start positions in the pizza(a slice with cells number 1..max slice cells number) 87 | * @param output list of valid and cutted slices 88 | */ 89 | public static void performStep(Pizza pizza, Step step, List startPositions, List output) { 90 | //1. Pick ups a steps list with minimal total cells number 91 | LOGGER.debug("STEP TO PERFORM " + step); 92 | //2. Cut all the step delta cells from pizza 93 | LOGGER.debug("pizza before step: " + pizza 94 | + "\ndelta to remove from the pizza: " + step.delta); 95 | pizza.getCells().removeAll(step.delta.cells); 96 | //3. remove step start position from total start positions 97 | startPositions.remove(step.startPosition); 98 | List returnedList = step.startPosition.cells; 99 | returnedList.addAll(step.delta.cells); 100 | Slice finalSlice = new Slice(returnedList); 101 | LOGGER.debug("PIZZA AFTER STEP:" + pizza); 102 | //3. Add the step cells to an output slice if it's valid 103 | if (finalSlice.isValid(pizza)) { 104 | output.add(finalSlice); 105 | } 106 | //4. add start position + delta to start positions 107 | else { 108 | startPositions.add(finalSlice); 109 | } 110 | } 111 | 112 | /** 113 | * Selects a step which start position has minimal delta in all the steps 114 | * 115 | * @param steps available steps 116 | * @return a step with minimal delta 117 | */ 118 | public static Step selectStep(Map> steps) { 119 | //TODO test and refactor this peace of shit properly !! 120 | List min = steps.values().stream() 121 | .min(Comparator.comparingLong(value -> 122 | value.stream() 123 | .map(step -> step.delta.cells.size()) 124 | .count())) 125 | .get(); 126 | if (!min.isEmpty()) { 127 | LOGGER.debug("steps list with minimal number of delta cells: " + min); 128 | return min.get(0); 129 | } else { 130 | Optional> optionalStep = steps.values().stream().filter(steps1 -> !steps1.isEmpty()).findFirst(); 131 | if (optionalStep.isPresent()) { 132 | final Step step = optionalStep.get().get(0); 133 | LOGGER.info("Selected step to perform:" + step); 134 | return step; 135 | } else return null; 136 | } 137 | } 138 | 139 | /** 140 | * * Finds a cell type(tomato or mushroom) with minimal cells numbers
141 | * * Generates a list of one cell slices from them
142 | * * Deletes the slices from the pizza
143 | * 144 | * @param pizza given pizza 145 | * @return slices that are start positions for future slicing process 146 | */ 147 | public static List cutAllStartPositions(Pizza pizza) { 148 | //1.Finds a cell type(tomato or mushroom) with minimal cells numbers 149 | List mushrooms = pizza.getCells().stream() 150 | .filter(cell -> cell.ingredient.equals(Ingredient.MUSHROOM)) 151 | .collect(Collectors.toList()); 152 | List tomatoes = pizza.getCells().stream() 153 | .filter(cell -> cell.ingredient.equals(Ingredient.TOMATO)) 154 | .collect(Collectors.toList()); 155 | LOGGER.info("cutAllStartPositions for pizza: " 156 | + "\n" + pizza 157 | + "\nmushrooms number: " + mushrooms.size() 158 | + "\ntomatoes number: " + tomatoes.size()); 159 | List startPositions = null; 160 | if (mushrooms.size() > tomatoes.size()) { 161 | startPositions = tomatoes.stream() 162 | .map(Slice::new) 163 | .collect(Collectors.toList()); 164 | pizza.setCells(mushrooms); 165 | } else { 166 | startPositions = mushrooms.stream() 167 | .map(Slice::new) 168 | .collect(Collectors.toList()); 169 | pizza.setCells(tomatoes); 170 | } 171 | LOGGER.debug("pizza with removed start positions:" 172 | + "\n" + pizza); 173 | return startPositions; 174 | } 175 | 176 | } 177 | -------------------------------------------------------------------------------- /src/main/java/com/google/hashcode/utils/StepsComparator.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import com.google.hashcode.entity.Step; 4 | 5 | import java.util.Comparator; 6 | import java.util.List; 7 | 8 | /** 9 | * @author Grigoriy Lyashenko (Grog). 10 | */ 11 | //TODO examine this class work by parameterized tests 12 | public class StepsComparator implements Comparator> { 13 | 14 | @Override 15 | public int compare(List o1, List o2) { 16 | long o1CellsCount = o1.stream() 17 | .mapToLong(step -> step.delta.cells.size()) 18 | .sum(); 19 | long o2CellsCount = o2.stream() 20 | .mapToLong(step -> step.delta.cells.size()) 21 | .sum(); 22 | return Long.compare(o1CellsCount, o2CellsCount); 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/resources/logback.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | INFO 7 | ACCEPT 8 | DENY 9 | 10 | 11 | 12 | %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n 13 | 14 | 15 | 16 | 17 | 18 | ./pizzaSlicingDebug.log 19 | 20 | 21 | %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n 22 | 23 | 24 | 25 | 26 | 27 | ./pizzaSlicingAudit.log 28 | 29 | 30 | %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /src/test/java/com/google/hashcode/AppTest.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode; 2 | 3 | import org.junit.Test; 4 | 5 | import java.io.IOException; 6 | 7 | public class AppTest { 8 | 9 | @Test 10 | public void main() throws IOException { 11 | // App.main(new String[0]); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/test/java/com/google/hashcode/entity/PizzaTest.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import com.google.hashcode.utils.IoUtils; 4 | import org.junit.Before; 5 | import org.junit.Test; 6 | 7 | import java.io.File; 8 | import java.io.IOException; 9 | import java.util.Optional; 10 | 11 | import static com.google.hashcode.utils.FilesPaths.EXAMPLE_INPUT_FILE_PATH; 12 | import static org.junit.Assert.assertEquals; 13 | import static org.junit.Assert.assertFalse; 14 | 15 | /** 16 | * @author Grigoriy Lyashenko (Grog). 17 | */ 18 | public class PizzaTest { 19 | 20 | private Pizza examplePizza; 21 | 22 | @Before 23 | public void setup() throws IOException { 24 | examplePizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH)); 25 | } 26 | 27 | @Test 28 | public void getCell() throws Exception { 29 | assertEquals(examplePizza.getCell(0, 0), Optional.of(new Cell(0, 0, Ingredient.TOMATO))); 30 | } 31 | 32 | @Test 33 | public void getCellException() throws Exception { 34 | Optional cell = examplePizza.getCell(100500, 0); 35 | assertFalse(cell.isPresent()); 36 | } 37 | 38 | @Test 39 | public void testToString() throws IOException { 40 | assertEquals("inputDataSets/example.inSliceInstructions: \n" + 41 | "min 1 ingredient per slice, max 6 cells per slice \n" + 42 | " 0 1 2 3 4\n" + 43 | "0 T T T T T \n" + 44 | "1 T M M M T \n" + 45 | "2 T T T T T", examplePizza.toString()); 46 | } 47 | 48 | @Test 49 | public void containsCells() { 50 | //given a slice based on the pizza cells 51 | 52 | } 53 | 54 | } -------------------------------------------------------------------------------- /src/test/java/com/google/hashcode/entity/SliceTest.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.entity; 2 | 3 | import com.google.hashcode.utils.IoUtils; 4 | import org.junit.Before; 5 | import org.junit.Test; 6 | 7 | import java.io.File; 8 | import java.io.IOException; 9 | import java.util.ArrayList; 10 | import java.util.Arrays; 11 | import java.util.Collections; 12 | 13 | import static com.google.hashcode.utils.FilesPaths.EXAMPLE_INPUT_FILE_PATH; 14 | import static org.junit.Assert.*; 15 | 16 | /** 17 | * @author Grigoriy Lyashenko (Grog). 18 | */ 19 | public class SliceTest { 20 | private Pizza pizza; 21 | 22 | @Before 23 | public void setup() throws IOException { 24 | pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH)); 25 | } 26 | 27 | @Test 28 | public void isValid() throws Exception { 29 | Slice invalidSlice = new Slice(pizza.getCells()); 30 | assertFalse(invalidSlice.isValid(pizza)); 31 | //create a valid slice 32 | Slice validSlice = new Slice(Arrays.asList( 33 | new Cell(0, 0, Ingredient.TOMATO), 34 | new Cell(0, 1, Ingredient.MUSHROOM))); 35 | assertTrue(validSlice.isValid(pizza)); 36 | } 37 | 38 | @Test 39 | public void generateStepDeltaBelow() { 40 | Slice slice = new Slice(Arrays.asList( 41 | new Cell(0, 0, Ingredient.MUSHROOM), 42 | new Cell(0, 1, Ingredient.TOMATO))); 43 | assertEquals(2, slice.generateStepBelow(pizza).delta.cells.size()); 44 | } 45 | 46 | @Test 47 | public void centGenerateStepDeltaAbove() { 48 | Slice slice = new Slice(Arrays.asList( 49 | new Cell(0, 0, Ingredient.MUSHROOM), 50 | new Cell(0, 1, Ingredient.TOMATO))); 51 | assertEquals(null, slice.generateStepAbove(pizza)); 52 | } 53 | 54 | @Test 55 | public void generateStepDeltaAbove() { 56 | Slice slice = new Slice(Arrays.asList( 57 | new Cell(1, 0, Ingredient.MUSHROOM), 58 | new Cell(1, 1, Ingredient.TOMATO))); 59 | assertEquals(2, slice.generateStepAbove(pizza).delta.cells.size()); 60 | } 61 | 62 | @Test 63 | public void generateStepLeft() { 64 | Slice slice = new Slice(new ArrayList<>(Collections.singletonList( 65 | new Cell(1, 1, Ingredient.MUSHROOM)))); 66 | assertEquals(2, slice.generateStepLeft(pizza).size()); 67 | } 68 | 69 | @Test 70 | public void cantGenerateStepLeft() { 71 | Slice slice = new Slice(Arrays.asList( 72 | new Cell(0, 0, Ingredient.MUSHROOM), 73 | new Cell(0, 1, Ingredient.TOMATO))); 74 | assertEquals(null, slice.generateStepLeft(pizza)); 75 | } 76 | 77 | @Test 78 | public void generateStepRight() { 79 | Slice slice = new Slice(Arrays.asList( 80 | new Cell(0, 0, Ingredient.MUSHROOM), 81 | new Cell(0, 1, Ingredient.TOMATO))); 82 | assertEquals(1, slice.generateStepRight(pizza).delta.cells.size()); 83 | assertEquals(3, slice.generateStepRight(pizza).size()); 84 | } 85 | 86 | @Test 87 | public void testToString() { 88 | Slice slice = new Slice(Arrays.asList( 89 | new Cell(0, 0, Ingredient.MUSHROOM))); 90 | assertEquals("slice : \n" + 91 | " 0\n" + 92 | "0 M", slice.toString()); 93 | Slice slice1 = new Slice(Arrays.asList( 94 | new Cell(2, 3, Ingredient.TOMATO), 95 | new Cell(0, 1, Ingredient.MUSHROOM)) 96 | ); 97 | assertEquals("slice : \n" + 98 | " 0 1 2 3\n" + 99 | "0 M \n" + 100 | "1 \n" + 101 | "2 T", slice1.toString()); 102 | } 103 | } -------------------------------------------------------------------------------- /src/test/java/com/google/hashcode/utils/IoUtilsTest.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import com.google.hashcode.entity.Cell; 4 | import com.google.hashcode.entity.Ingredient; 5 | import com.google.hashcode.entity.Slice; 6 | import org.junit.Test; 7 | 8 | import java.io.IOException; 9 | import java.net.URISyntaxException; 10 | import java.nio.file.Files; 11 | import java.nio.file.Paths; 12 | import java.util.Arrays; 13 | import java.util.List; 14 | 15 | import static org.junit.Assert.assertEquals; 16 | 17 | /** 18 | * @author Grigoriy Lyashenko (Grog). 19 | */ 20 | public class IoUtilsTest { 21 | private static final String TEST_OUTPUT_FILE = "testOutput.txt"; 22 | private static final String PARAGON_OUTPUT_EXAMPLE_FILE = "src/test/resources/paragonOutputExample.txt"; 23 | private static final String EXAMPLE_PIZZA_FILE = FilesPaths.EXAMPLE_INPUT_FILE_PATH; 24 | 25 | private static List createSlicesForParagonOutputExample() { 26 | Slice slice0 = new Slice(); 27 | Slice slice1 = new Slice(); 28 | Slice slice2 = new Slice(); 29 | 30 | slice0.cells.add(new Cell(0, 0, Ingredient.TOMATO)); 31 | slice0.cells.add(new Cell(1, 0, Ingredient.TOMATO)); 32 | slice0.cells.add(new Cell(2, 0, Ingredient.TOMATO)); 33 | slice0.cells.add(new Cell(0, 1, Ingredient.TOMATO)); 34 | slice0.cells.add(new Cell(1, 1, Ingredient.MUSHROOM)); 35 | slice0.cells.add(new Cell(2, 1, Ingredient.TOMATO)); 36 | 37 | slice1.cells.add(new Cell(0, 2, Ingredient.TOMATO)); 38 | slice1.cells.add(new Cell(1, 2, Ingredient.MUSHROOM)); 39 | slice1.cells.add(new Cell(2, 2, Ingredient.TOMATO)); 40 | 41 | slice2.cells.add(new Cell(0, 3, Ingredient.TOMATO)); 42 | slice2.cells.add(new Cell(1, 3, Ingredient.MUSHROOM)); 43 | slice2.cells.add(new Cell(2, 3, Ingredient.TOMATO)); 44 | slice2.cells.add(new Cell(0, 4, Ingredient.TOMATO)); 45 | slice2.cells.add(new Cell(1, 4, Ingredient.TOMATO)); 46 | slice2.cells.add(new Cell(2, 4, Ingredient.TOMATO)); 47 | 48 | return Arrays.asList(slice0, slice1, slice2); 49 | } 50 | 51 | @Test 52 | public void parseExampleInput() throws IOException { 53 | List input = IoUtils.parsePizza(EXAMPLE_PIZZA_FILE); 54 | } 55 | 56 | @Test 57 | public void parseExampleSliceInstructions() throws IOException { 58 | assertEquals("We expect min 1 ingredient per slice", 1, 59 | IoUtils.parseSliceInstructions(EXAMPLE_PIZZA_FILE).getMinNumberOfIngredientPerSlice().intValue()); 60 | assertEquals("We expect max 6 cells per slice", 6, 61 | IoUtils.parseSliceInstructions(EXAMPLE_PIZZA_FILE).getMaxNumberOfCellsPerSlice().intValue()); 62 | } 63 | 64 | @Test 65 | public void parseSlicesToOutputFormat() throws IOException, URISyntaxException { 66 | //Given a list of slices 67 | List slicesForParagonOutputExample = createSlicesForParagonOutputExample(); 68 | //Then parse slices according to the output format 69 | String outputDate = IoUtils.parseSlices(slicesForParagonOutputExample); 70 | IoUtils.writeToFile(TEST_OUTPUT_FILE, outputDate); 71 | assertEquals(IoUtils.readFromFile(PARAGON_OUTPUT_EXAMPLE_FILE), IoUtils.readFromFile(TEST_OUTPUT_FILE)); 72 | //clean the file under the test 73 | Files.deleteIfExists(Paths.get(TEST_OUTPUT_FILE)); 74 | } 75 | } -------------------------------------------------------------------------------- /src/test/java/com/google/hashcode/utils/SlicingMethodsTest.java: -------------------------------------------------------------------------------- 1 | package com.google.hashcode.utils; 2 | 3 | import com.google.hashcode.entity.*; 4 | import org.junit.Before; 5 | import org.junit.Test; 6 | 7 | import java.io.File; 8 | import java.io.IOException; 9 | import java.util.ArrayList; 10 | import java.util.Arrays; 11 | import java.util.List; 12 | import java.util.Map; 13 | 14 | import static com.google.hashcode.utils.FilesPaths.EXAMPLE_INPUT_FILE_PATH; 15 | import static org.junit.Assert.assertEquals; 16 | 17 | /** 18 | * @author Grigoriy Lyashenko (Grog). 19 | */ 20 | public class SlicingMethodsTest { 21 | 22 | private Pizza pizza; 23 | 24 | @Before 25 | public void setup() throws IOException { 26 | pizza = new Pizza(new File(EXAMPLE_INPUT_FILE_PATH), IoUtils.parsePizza(EXAMPLE_INPUT_FILE_PATH), IoUtils.parseSliceInstructions(EXAMPLE_INPUT_FILE_PATH)); 27 | } 28 | 29 | @Test 30 | public void getAvailableSteps() throws IOException { 31 | List output = new ArrayList<>(); 32 | Map> actualMap = SlicingMethods.getAvailableSteps(pizza, SlicingMethods.cutAllStartPositions(pizza), output); 33 | assertEquals(3, actualMap.keySet().size()); 34 | assertEquals(3, actualMap.get(new Slice(new Cell(1, 1, Ingredient.MUSHROOM))).size()); 35 | assertEquals(2, actualMap.get(new Slice(new Cell(1, 2, Ingredient.MUSHROOM))).size()); 36 | assertEquals(3, actualMap.get(new Slice(new Cell(1, 3, Ingredient.MUSHROOM))).size()); 37 | } 38 | 39 | @Test 40 | public void cutAllStartPositions() throws IOException { 41 | List expected = Arrays.asList( 42 | new Slice(new Cell(1, 1, Ingredient.MUSHROOM)), 43 | new Slice(new Cell(1, 2, Ingredient.MUSHROOM)), 44 | new Slice(new Cell(1, 3, Ingredient.MUSHROOM)) 45 | ); 46 | assertEquals(expected, SlicingMethods.cutAllStartPositions(pizza)); 47 | assertEquals("We expect pizza size reduced to 15-3=12", 12, pizza.getCells().size()); 48 | } 49 | 50 | @Test 51 | public void performStep() { 52 | List startPositions = SlicingMethods.cutAllStartPositions(pizza); 53 | List output = new ArrayList<>(); 54 | Map> availableSteps = SlicingMethods.getAvailableSteps(pizza, startPositions, output); 55 | SlicingMethods.performStep(pizza, SlicingMethods.selectStep(availableSteps), startPositions, output); 56 | assertEquals(11, pizza.getCells().size()); 57 | } 58 | } -------------------------------------------------------------------------------- /src/test/resources/paragonOutputExample.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 0 0 2 1 3 | 0 2 2 2 4 | 0 3 2 4 -------------------------------------------------------------------------------- /submitResultsViaSelenium: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | submitResults 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 |
submitResults
type//input[@type="file"][1]/Users/greg/GIT/GoogleHashCode2017/googleHashCode_Pizza.zip
pause5000
type//input[@type="file"][1]/Users/greg/GIT/GoogleHashCode2017/outputDataSet/example.txt
pause2000
type//input[@type="file"][1]/Users/greg/GIT/GoogleHashCode2017/outputDataSet/example.txt
pause2000
type//input[@type="file"][1]/Users/greg/GIT/GoogleHashCode2017/outputDataSet/example.txt
pause2000
type//input[@type="file"][1]/Users/greg/GIT/GoogleHashCode2017/outputDataSet/example.txt
pause2000
click//md-card[2]/md-card-actions/button[2]
70 | 71 | 72 | -------------------------------------------------------------------------------- /zipSourceCode.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | #removes an existing archive 3 | rm googleHashCode_Pizza.* 4 | #zip all the project code 5 | zip -r googleHashCode_Pizza . --------------------------------------------------------------------------------