From 5c0d46ffc6cea3f393f246efa170fdf2079262d3 Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 6 Jul 2022 10:11:34 -0400 Subject: [PATCH 01/91] Update _toc.yml --- src/_toc.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/_toc.yml b/src/_toc.yml index b17533b..1aae987 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -5,14 +5,14 @@ format: jb-book root: intro chapters: - file: content -- file: markdown - sections: - - file: decision_tree/decision_tree.ipynb - - file: notebooks - file: openmp_c/parallel_for.ipynb sections: - file: build_rex.md - file: MulticoreMultiCPU/2-1MultiCoreMultiCPU.ipynb - file: SIMDVector - file: GPUAccel +- file: markdown + sections: + - file: decision_tree/decision_tree.ipynb + - file: notebooks From e77b07282644a12251b445d499aa3f5b9154aaa5 Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 6 Jul 2022 10:12:18 -0400 Subject: [PATCH 02/91] Update intro.md --- src/intro.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/intro.md b/src/intro.md index 132c1dc..ef85c3d 100644 --- a/src/intro.md +++ b/src/intro.md @@ -1,4 +1,4 @@ -Welcome to the Book of Parallel Programming and Performance Optimization With OpenMP +Introduction ============================ This is a small sample book to give you a feel for how book content is From 5334fc5e5dbfe4f9dbdf951c03941482a62ae2de Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 6 Jul 2022 10:12:54 -0400 Subject: [PATCH 03/91] Create preface.md --- src/preface.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 src/preface.md diff --git a/src/preface.md b/src/preface.md new file mode 100644 index 0000000..0818409 --- /dev/null +++ b/src/preface.md @@ -0,0 +1,2 @@ +## Preface +====== From 2aec9753412fe75c53a3c3d7dc8225080794eccf Mon Sep 17 00:00:00 2001 From: xinyao Date: Sun, 10 Jul 2022 14:10:27 -0400 Subject: [PATCH 04/91] Test: I want to see how to add a new section --- src/_toc.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/_toc.yml b/src/_toc.yml index 1aae987..9b51e24 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -8,6 +8,7 @@ chapters: - file: openmp_c/parallel_for.ipynb sections: - file: build_rex.md +- file: MulticoreMultiCPU - file: MulticoreMultiCPU/2-1MultiCoreMultiCPU.ipynb - file: SIMDVector - file: GPUAccel From 065f4f80c15a3f96584901214528324aa5f6ae4d Mon Sep 17 00:00:00 2001 From: xinyao Date: Sun, 10 Jul 2022 14:23:03 -0400 Subject: [PATCH 05/91] Test2: I want to check how to add a subsection --- src/_toc.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/_toc.yml b/src/_toc.yml index 9b51e24..4a28469 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -9,7 +9,8 @@ chapters: sections: - file: build_rex.md - file: MulticoreMultiCPU -- file: MulticoreMultiCPU/2-1MultiCoreMultiCPU.ipynb + sections: + - file: MulticoreMultiCPU/2-1MultiCoreMultiCPU.ipynb - file: SIMDVector - file: GPUAccel - file: markdown From 3c436451925d5ac09031ae5151aa3f660480851d Mon Sep 17 00:00:00 2001 From: xinyao Date: Tue, 12 Jul 2022 15:23:48 -0400 Subject: [PATCH 06/91] Orgnize the structure of the book --- src/GPUAccelerators/1_DataMapping.ipynb | 33 ++++++ src/GPUAccelerators/2_Metadirective.ipynb | 33 ++++++ .../{SectionStarter3.md => plan.md} | 0 .../1_MIMDArchitecture.ipynb | 41 +++++++ .../2-1MultiCoreMultiCPU.ipynb | 100 ------------------ src/MultiCoreMultiCPU/2-1Multicoreintro.md | 0 src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb | 33 ++++++ .../3_SynchronizationThreads.ipynb | 33 ++++++ .../4_AsynchronousTasking.ipynb | 33 ++++++ .../5_ExplicitDistribution.ipynb | 33 ++++++ src/MultiCoreMultiCPU/SectionStarter1.md | 4 - src/MultiCoreMultiCPU/plan.md | 38 +++++++ src/MulticoreMultiCPU.md | 31 +----- .../{SectionStarter2.md => plan.md} | 0 .../build_rex.md | 0 .../decision_tree/agaricuslepiotatest1.csv | 0 .../decision_tree/agaricuslepiotatrain1.csv | 0 .../decision_tree/decision_tree.ipynb | 0 src/{ => SomethingMayUsefulInFuture}/logo.png | Bin .../markdown.md | 0 .../notebooks.ipynb | 0 .../preface.md | 0 src/_toc.yml | 15 +-- src/openmpIntro.md | 4 + src/openmp_c/1_IntroductionOfOpenMP.ipynb | 76 +++++++++++++ src/openmp_c/parallel_for.ipynb | 4 +- 26 files changed, 369 insertions(+), 142 deletions(-) create mode 100644 src/GPUAccelerators/1_DataMapping.ipynb create mode 100644 src/GPUAccelerators/2_Metadirective.ipynb rename src/GPUAccelerators/{SectionStarter3.md => plan.md} (100%) create mode 100644 src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb delete mode 100644 src/MultiCoreMultiCPU/2-1MultiCoreMultiCPU.ipynb delete mode 100644 src/MultiCoreMultiCPU/2-1Multicoreintro.md create mode 100644 src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb create mode 100644 src/MultiCoreMultiCPU/3_SynchronizationThreads.ipynb create mode 100644 src/MultiCoreMultiCPU/4_AsynchronousTasking.ipynb create mode 100644 src/MultiCoreMultiCPU/5_ExplicitDistribution.ipynb delete mode 100644 src/MultiCoreMultiCPU/SectionStarter1.md create mode 100644 src/MultiCoreMultiCPU/plan.md rename src/SIMDandVectorArchitecture/{SectionStarter2.md => plan.md} (100%) rename src/{ => SomethingMayUsefulInFuture}/build_rex.md (100%) rename src/{ => SomethingMayUsefulInFuture}/decision_tree/agaricuslepiotatest1.csv (100%) rename src/{ => SomethingMayUsefulInFuture}/decision_tree/agaricuslepiotatrain1.csv (100%) rename src/{ => SomethingMayUsefulInFuture}/decision_tree/decision_tree.ipynb (100%) rename src/{ => SomethingMayUsefulInFuture}/logo.png (100%) rename src/{ => SomethingMayUsefulInFuture}/markdown.md (100%) rename src/{ => SomethingMayUsefulInFuture}/notebooks.ipynb (100%) rename src/{ => SomethingMayUsefulInFuture}/preface.md (100%) create mode 100644 src/openmpIntro.md create mode 100644 src/openmp_c/1_IntroductionOfOpenMP.ipynb diff --git a/src/GPUAccelerators/1_DataMapping.ipynb b/src/GPUAccelerators/1_DataMapping.ipynb new file mode 100644 index 0000000..4fad447 --- /dev/null +++ b/src/GPUAccelerators/1_DataMapping.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Data Mapping" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/2_Metadirective.ipynb b/src/GPUAccelerators/2_Metadirective.ipynb new file mode 100644 index 0000000..36cc996 --- /dev/null +++ b/src/GPUAccelerators/2_Metadirective.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e11fa50b-a61a-4358-a6dc-395a18d715fa", + "metadata": {}, + "source": [ + "# Metadirective (possible separate section)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/SectionStarter3.md b/src/GPUAccelerators/plan.md similarity index 100% rename from src/GPUAccelerators/SectionStarter3.md rename to src/GPUAccelerators/plan.md diff --git a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb new file mode 100644 index 0000000..9e49edb --- /dev/null +++ b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -0,0 +1,41 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9570e6db-1f44-4ef8-860c-6c4fe1f2344a", + "metadata": {}, + "source": [ + "# Multicore and Multi-CPU shared memory systems" + ] + }, + { + "cell_type": "markdown", + "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", + "metadata": {}, + "source": [ + "As previously mentioned in this book we will be discussing the applications of OpenMP on MultiCore and MultiCPU machines. Before we understand the need for OpenMP we first must understand the need for MultiCore and MutliCPU machines. As most of you may recall Moores's Law states CPUs double in frequency every two years. Which was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then multicore machines have taken over the consumer and corprate market, with most computers and even phone coming standard with mutliple cores. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/2-1MultiCoreMultiCPU.ipynb b/src/MultiCoreMultiCPU/2-1MultiCoreMultiCPU.ipynb deleted file mode 100644 index dc1a9f1..0000000 --- a/src/MultiCoreMultiCPU/2-1MultiCoreMultiCPU.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "# 2-1 Intro to Multicore and Multi-CPU Machines\n", - "\n", - "As previously mentioned in this book we will be discussing the applications of OpenMP on MultiCore and MultiCPU machines. Before we understand the need for OpenMP we first must understand the need for MultiCore and MutliCPU machines. As most of you may recall Moores's Law states CPUs double in frequency every two years. Which was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then multicore machines have taken over the consumer and corprate market, with most computers and even phone coming standard with mutliple cores. \n", - "\n", - "## 2-1-1 Intro to OpenMP\n", - "\n", - "OpenMP is a standard API for defining multi-threaded shared memory-programs. Which means that each thread or proccess can have access to all available memory. This doesn't mean that this is necessarily true but we will get into different memory protocols later. OpenMP is a portale, threaded, shared-memory programming specification with \"light\" syntax. OpenMP behavoir is directly dependent on the OpenMP implementation. Capabilties of this implementation can enable the programmer to seperate program into serial and parallel reigons rather than just concurrently running threads, hides stack managemend, and provides synchronization of constructs. That being said OpenMP will not garuntee speedup, parallelize dependencies, or prevent data racing. Data racing, keeping track of dependencies, and working towards a speedup are all up to the programmer. \n", - "\n", - "The following is a example of a simple OpenMP program:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "clang: warning: treating 'c' input as 'c++' when in C++ mode, this behavior is deprecated [-Wdeprecated]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n" - ] - } - ], - "source": [ - "//%compiler: clang++\n", - "//%cflags: -fopenmp\n", - "\n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "using namespace std;\n", - "\n", - "char message[] = \"Hello World\";\n", - "void hello(){\n", - " printf(\"%s\\n\", message);\n", - "}\n", - "int main(int argc, char *argv[]){\n", - " int threads = 4;\n", - " #pragma omp parallel num_threads(threads)\n", - " hello();\n", - " \n", - " return 0;\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" - }, - "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/src/MultiCoreMultiCPU/2-1Multicoreintro.md b/src/MultiCoreMultiCPU/2-1Multicoreintro.md deleted file mode 100644 index e69de29..0000000 diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb new file mode 100644 index 0000000..e56cc09 --- /dev/null +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f8a3d29-cc57-49bc-88f7-5602d4491cae", + "metadata": {}, + "source": [ + "# Creating SPMD parallelism using OpenMP parallel and teams directive" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/3_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/3_SynchronizationThreads.ipynb new file mode 100644 index 0000000..bb75210 --- /dev/null +++ b/src/MultiCoreMultiCPU/3_SynchronizationThreads.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "274986cf-eb9d-43fb-9e5e-747375967074", + "metadata": {}, + "source": [ + "# Synchronization of threads using barrier and order directive" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/4_AsynchronousTasking.ipynb b/src/MultiCoreMultiCPU/4_AsynchronousTasking.ipynb new file mode 100644 index 0000000..09a25d1 --- /dev/null +++ b/src/MultiCoreMultiCPU/4_AsynchronousTasking.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "015cf5de-9b8c-4acf-b906-6c3acc1d83e6", + "metadata": {}, + "source": [ + "# Asynchronous tasking" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/5_ExplicitDistribution.ipynb b/src/MultiCoreMultiCPU/5_ExplicitDistribution.ipynb new file mode 100644 index 0000000..2593b67 --- /dev/null +++ b/src/MultiCoreMultiCPU/5_ExplicitDistribution.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8110bebe-e1d8-4a00-9263-eda21eb9368e", + "metadata": {}, + "source": [ + "# Explicit distribution of work using single, sections, workshring-loop, and distribute construct" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/SectionStarter1.md b/src/MultiCoreMultiCPU/SectionStarter1.md deleted file mode 100644 index d8a6283..0000000 --- a/src/MultiCoreMultiCPU/SectionStarter1.md +++ /dev/null @@ -1,4 +0,0 @@ -Parallel Programming for Multicore and Multi-CPU Machines -========================================================= - -Temporary page indicating start of a section diff --git a/src/MultiCoreMultiCPU/plan.md b/src/MultiCoreMultiCPU/plan.md new file mode 100644 index 0000000..ffc4632 --- /dev/null +++ b/src/MultiCoreMultiCPU/plan.md @@ -0,0 +1,38 @@ +Parallel Programming for Multicore and Multi-CPU Machines +========================================================= + +Temporary page indicating start of a section + + +# Parallel Programming for Multicore and Multi-CPU Machines + +## Introduction into Multicore and Multi-CPU machines + +Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. + + +## 1. Multicore and Multi-CPU shared memory systems. +Describe the architecture which can be considered as MIMD architecture. Each thread/core has its own execution context and program counter. All threads/core shared memory, which could be NUMA, etc.. +About 1-2 pages, have some figures for the multicore/multi-CPU shared memory systems. System approach of parallel programming for this architecture, e.g. using pthread. +Divide into paragraphs and identify the content for each paragraph +#### What are the Multi-core and multi-CPU architectures +#### Cache-coherent shared memory for multi-core and multi-CPU architecture, focusing on the NUMA aspect, shared memory aspect, and memory consistency model. The implication of shared memory to performance, e.g. false-sharing issue, memory bandwidth challenges, synchronization cost +#### PThread programming models used so far and for a long time. + and - of pthreads +#### Synchronization between threads and cores, e.g. mutual exclusion, etc + +MIMD architecture consists of processors that operate independently and asynchronously from one another. MIMD architecture systems consist of many processors that can have much common memory or memory that is exclusive to one. These terms mean many processes can execute instructions at any time with any piece or segment of data. MIMD architecture consists of two different types of architecture; Shared Memory MIMD architecture and Distributed Memory MIMD architecture. + +Shared Memory MIMD systems have the following characteristics. Shared Memory MIMD groups processors and memory. Any processor can access that memory through a communication channel designated by the programmer. Finally, the memory addresses are shared between processors. On the other hand, Distributed Memory MIMD systems have their own set of characteristics. One, memory and processors are grouped together in pairs known as processing elements. Which is linked to other PEs through the use of communication channels. Finally, each PE communicates with each other by sending messages, communication isn’t as open like that of a Shared Memory MIMD system. + + +## 2. Creating SPMD parallelism using OpenMP parallel and teams directive +#### Controlling number of threads and teams +#### Diverge the work for threads using mask directive and omp_get_thread_num +#### Synchronization of threads using barrier and order directive + +Open-MP allows for the creation of shared-memory parallel programs. In this Chapter, we will be discussing Single Program, Multiple Data, or SPMD for short. SPMD style uses a number of individual processors or threads to carry out the same program or computation on different sets of data simultaneously. SPMD style parallel programming is an example of a low-level thread-specific programming style. Which can be identified by the following characteristics: + + +## 3. Asynchronous tasking + +## 4. Explicit distribution of work using single, sections, workshring-loop, and distribute construct diff --git a/src/MulticoreMultiCPU.md b/src/MulticoreMultiCPU.md index d7d5537..e3985d1 100644 --- a/src/MulticoreMultiCPU.md +++ b/src/MulticoreMultiCPU.md @@ -1,32 +1,3 @@ # Parallel Programming for Multicore and Multi-CPU Machines -## Introduction into Multicore and Multi-CPU machines - -Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. - - -## 1. Multicore and Multi-CPU shared memory systems. -Describe the architecture which can be considered as MIMD architecture. Each thread/core has its own execution context and program counter. All threads/core shared memory, which could be NUMA, etc.. -About 1-2 pages, have some figures for the multicore/multi-CPU shared memory systems. System approach of parallel programming for this architecture, e.g. using pthread. -Divide into paragraphs and identify the content for each paragraph -#### What are the Multi-core and multi-CPU architectures -#### Cache-coherent shared memory for multi-core and multi-CPU architecture, focusing on the NUMA aspect, shared memory aspect, and memory consistency model. The implication of shared memory to performance, e.g. false-sharing issue, memory bandwidth challenges, synchronization cost -#### PThread programming models used so far and for a long time. + and - of pthreads -#### Synchronization between threads and cores, e.g. mutual exclusion, etc - -MIMD architecture consists of processors that operate independently and asynchronously from one another. MIMD architecture systems consist of many processors that can have much common memory or memory that is exclusive to one. These terms mean many processes can execute instructions at any time with any piece or segment of data. MIMD architecture consists of two different types of architecture; Shared Memory MIMD architecture and Distributed Memory MIMD architecture. - -Shared Memory MIMD systems have the following characteristics. Shared Memory MIMD groups processors and memory. Any processor can access that memory through a communication channel designated by the programmer. Finally, the memory addresses are shared between processors. On the other hand, Distributed Memory MIMD systems have their own set of characteristics. One, memory and processors are grouped together in pairs known as processing elements. Which is linked to other PEs through the use of communication channels. Finally, each PE communicates with each other by sending messages, communication isn’t as open like that of a Shared Memory MIMD system. - - -## 2. Creating SPMD parallelism using OpenMP parallel and teams directive -#### Controlling number of threads and teams -#### Diverge the work for threads using mask directive and omp_get_thread_num -#### Synchronization of threads using barrier and order directive - -Open-MP allows for the creation of shared-memory parallel programs. In this Chapter, we will be discussing Single Program, Multiple Data, or SPMD for short. SPMD style uses a number of individual processors or threads to carry out the same program or computation on different sets of data simultaneously. SPMD style parallel programming is an example of a low-level thread-specific programming style. Which can be identified by the following characteristics: - - -## 3. Asynchronous tasking - -## 4. Explicit distribution of work using single, sections, workshring-loop, and distribute construct +In this section, we will introduce ..... \ No newline at end of file diff --git a/src/SIMDandVectorArchitecture/SectionStarter2.md b/src/SIMDandVectorArchitecture/plan.md similarity index 100% rename from src/SIMDandVectorArchitecture/SectionStarter2.md rename to src/SIMDandVectorArchitecture/plan.md diff --git a/src/build_rex.md b/src/SomethingMayUsefulInFuture/build_rex.md similarity index 100% rename from src/build_rex.md rename to src/SomethingMayUsefulInFuture/build_rex.md diff --git a/src/decision_tree/agaricuslepiotatest1.csv b/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv similarity index 100% rename from src/decision_tree/agaricuslepiotatest1.csv rename to src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv diff --git a/src/decision_tree/agaricuslepiotatrain1.csv b/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv similarity index 100% rename from src/decision_tree/agaricuslepiotatrain1.csv rename to src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv diff --git a/src/decision_tree/decision_tree.ipynb b/src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb similarity index 100% rename from src/decision_tree/decision_tree.ipynb rename to src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb diff --git a/src/logo.png b/src/SomethingMayUsefulInFuture/logo.png similarity index 100% rename from src/logo.png rename to src/SomethingMayUsefulInFuture/logo.png diff --git a/src/markdown.md b/src/SomethingMayUsefulInFuture/markdown.md similarity index 100% rename from src/markdown.md rename to src/SomethingMayUsefulInFuture/markdown.md diff --git a/src/notebooks.ipynb b/src/SomethingMayUsefulInFuture/notebooks.ipynb similarity index 100% rename from src/notebooks.ipynb rename to src/SomethingMayUsefulInFuture/notebooks.ipynb diff --git a/src/preface.md b/src/SomethingMayUsefulInFuture/preface.md similarity index 100% rename from src/preface.md rename to src/SomethingMayUsefulInFuture/preface.md diff --git a/src/_toc.yml b/src/_toc.yml index 4a28469..0d65c3f 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -5,16 +5,19 @@ format: jb-book root: intro chapters: - file: content -- file: openmp_c/parallel_for.ipynb +- file: openmpIntro sections: - - file: build_rex.md + - file: openmp_c/1_IntroductionOfOpenMP.ipynb - file: MulticoreMultiCPU sections: - - file: MulticoreMultiCPU/2-1MultiCoreMultiCPU.ipynb + - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb + - file: MultiCoreMultiCPU/2_UsingOpenMP.ipynb + - file: MultiCoreMultiCPU/3_SynchronizationThreads.ipynb + - file: MultiCoreMultiCPU/4_AsynchronousTasking.ipynb + - file: MultiCoreMultiCPU/5_ExplicitDistribution.ipynb - file: SIMDVector - file: GPUAccel -- file: markdown sections: - - file: decision_tree/decision_tree.ipynb - - file: notebooks + - file: GPUAccelerators/1_DataMapping.ipynb + - file: GPUAccelerators/2_Metadirective.ipynb diff --git a/src/openmpIntro.md b/src/openmpIntro.md new file mode 100644 index 0000000..a034584 --- /dev/null +++ b/src/openmpIntro.md @@ -0,0 +1,4 @@ +# OpenMP + +In this section, we will introduce what is OpenMP, give an example of OpenMP. +Then we will discuss 3 areas of implementations=which will be introduced in 3 big sections. \ No newline at end of file diff --git a/src/openmp_c/1_IntroductionOfOpenMP.ipynb b/src/openmp_c/1_IntroductionOfOpenMP.ipynb new file mode 100644 index 0000000..e32eb47 --- /dev/null +++ b/src/openmp_c/1_IntroductionOfOpenMP.ipynb @@ -0,0 +1,76 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3fd7c2f9-f29e-4057-982e-01836c6c6940", + "metadata": {}, + "source": [ + "# What is OpenMP?\n", + "OpenMP is a standard API for defining multi-threaded shared memory-programs. Which means that each thread or proccess can have access to all available memory. This doesn't mean that this is necessarily true but we will get into different memory protocols later. OpenMP is a portale, threaded, shared-memory programming specification with \"light\" syntax. OpenMP behavoir is directly dependent on the OpenMP implementation. Capabilties of this implementation can enable the programmer to seperate program into serial and parallel reigons rather than just concurrently running threads, hides stack managemend, and provides synchronization of constructs. That being said OpenMP will not garuntee speedup, parallelize dependencies, or prevent data racing. Data racing, keeping track of dependencies, and working towards a speedup are all up to the programmer. \n", + "\n", + "# An Example\n", + "The following is a example of a simple OpenMP program:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f8f811b6-102d-43e7-8fca-e36e2852f4d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "char message[] = \"Hello World\";\n", + "void hello(){\n", + " printf(\"%s\\n\", message);\n", + "}\n", + "int main(int argc, char *argv[]){\n", + " int threads = 4;\n", + " #pragma omp parallel num_threads(threads)\n", + " hello();\n", + " \n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca50a923-7866-429c-9b25-00bd7c69637f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "file_extension": ".c", + "mimetype": "text/plain", + "name": "c" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/openmp_c/parallel_for.ipynb b/src/openmp_c/parallel_for.ipynb index 4aa63cb..36a33ff 100644 --- a/src/openmp_c/parallel_for.ipynb +++ b/src/openmp_c/parallel_for.ipynb @@ -1,8 +1,8 @@ { "cells": [ { - "cell_type": "markdown", - "id": "increased-working", + "cell_type": "raw", + "id": "15a76a54-74a2-4d86-8796-b90556a99127", "metadata": {}, "source": [ "# `parallel for`" From b1cf59a800a000d8362faf0a398440f36ce66bcc Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 09:46:31 -0400 Subject: [PATCH 07/91] Some updates for chapter 1 and chapter 2 (#5) Chapter 1 (version 1) is finished. Chapter 2_1 (version 1) is finished. --- src/GPUAccelerators/1_architecture.ipynb | 43 ++++ .../1_MIMDArchitecture.ipynb | 113 +++++++++- src/MultiCoreMultiCPU/2.png | Bin 0 -> 44507 bytes src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb | 8 + src/MultiCoreMultiCPU/CPU_architecture.png | Bin 0 -> 54548 bytes src/MulticoreMultiCPU.md | 4 +- src/_config.yml | 2 +- src/_toc.yml | 2 + src/openmpIntro.md | 3 - src/openmp_c/0_13209261094r4F.png | Bin 0 -> 11310 bytes src/openmp_c/1.png | Bin 0 -> 277832 bytes src/openmp_c/1_IntroductionOfOpenMP.ipynb | 110 ++++++---- src/openmp_c/20190720101130709.png | Bin 0 -> 65467 bytes src/openmp_c/2_Syntax.ipynb | 202 ++++++++++++++++++ src/openmp_c/3_performance.ipynb | 82 +++++++ 15 files changed, 520 insertions(+), 49 deletions(-) create mode 100644 src/GPUAccelerators/1_architecture.ipynb create mode 100644 src/MultiCoreMultiCPU/2.png create mode 100644 src/MultiCoreMultiCPU/CPU_architecture.png create mode 100644 src/openmp_c/0_13209261094r4F.png create mode 100644 src/openmp_c/1.png create mode 100644 src/openmp_c/20190720101130709.png create mode 100644 src/openmp_c/2_Syntax.ipynb create mode 100644 src/openmp_c/3_performance.ipynb diff --git a/src/GPUAccelerators/1_architecture.ipynb b/src/GPUAccelerators/1_architecture.ipynb new file mode 100644 index 0000000..a09cf09 --- /dev/null +++ b/src/GPUAccelerators/1_architecture.ipynb @@ -0,0 +1,43 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf774897-c7f1-468e-97c3-82334472ff64", + "metadata": {}, + "source": [ + "# Vector Architectures\n", + "\n", + "The SIMD model is shown in the following figure and usually consists of two parts, a front-end computer, and a processor array.\n", + "\n", + "\n", + "A processor array is a collection of identical synchronous processing elements, each processor in the array has a small local memory in which distributed data resides during parallel processing.\n", + "The front end performs the application program in the usual serial method, but the problem commands the processor array to carry out SIMD operations in parallel.\n", + "\n", + "Vector architectures have advanced and changed significantly in the last decade, particularly from dedicated vector architecture machines to general-purpose CPUs with vector extensions. In 2011, Intel shipped general-purpose CPUs with the second version of the Advanced Vector Extensions (AVX2), followed by the AVX-512 extensions in 2013. The AVX2 extensions contain 256-bit lane widths and are very common in consumer CPUs. The AVX-512 extensions bring 512-bit lane widths into a few high-end consumer CPUs and high-performance CPU product lines. Beyond increasing lane width to 512 bits, AVX-512 brings many advanced features, most notably masking, an ideal solution for stridden loads and stores. The Arm architecture is another notable example of extending general-purpose CPUs to support SIMD. In 2016, Arm announced its Scalable Vector Extension (SVE) vector architecture for its high-end Arm CPUs to extend the aging NEON SIMD extensions.\n", + "The recent Fukagu supercomputer (ranked \\#1 in the November 2021 Top500 list and uses Fujitsu's Arm A64FX CPU with 512-bit vector length) represents the adoption of the Arm SVE architecture in production. \n", + "Arm SVE takes a unique approach to support SIMD architecture of different vector lane widths. Rather than creating a new set of extensions for higher lane widths as Intel does, SVE provides a vector length agnostic model, which allows the same code to run on different hardware with varying vector lengths. In other words, vendors can create vectors as long or short as needed, and the same machine code will run on any hardware. \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb index 9e49edb..6f502c8 100644 --- a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb +++ b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -13,8 +13,119 @@ "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", "metadata": {}, "source": [ - "As previously mentioned in this book we will be discussing the applications of OpenMP on MultiCore and MultiCPU machines. Before we understand the need for OpenMP we first must understand the need for MultiCore and MutliCPU machines. As most of you may recall Moores's Law states CPUs double in frequency every two years. Which was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then multicore machines have taken over the consumer and corprate market, with most computers and even phone coming standard with mutliple cores. " + "In this section, we will introduce the MIMD architecture, multi-CPU systems, multi-core systems, and multithreading. Through this section, the readers will understand the structure of computers for parallel computing. To lay the foundation for the introduction to OpenMP programming.\n" ] + }, + { + "cell_type": "markdown", + "id": "9cd9d924-2082-457c-8314-37dea2c1c1cd", + "metadata": {}, + "source": [ + "## MIMD Architecture\n", + "Multiple Instruction Multiple Data(MIMD) architecture consists of processors that operate independently and asynchronously from one another. MIMD architecture systems consist of many processors that can have much common memory or memory that is exclusive to one. These terms mean many processes can execute instructions at any time with any piece or segment of data. MIMD architecture consists of two different types of architecture: Shared Memory MIMD architecture and Distributed Memory MIMD architecture. \n", + "\n", + "Shared Memory MIMD systems have the following characteristics. Shared Memory MIMD groups processors and memory. Any processor can access that memory through a communication channel designated by the programmer. Finally, the memory addresses are shared between processors. On the other hand, Distributed Memory MIMD systems have their own set of characteristics. First, memory and processors are grouped together in pairs known as processing elements. Which is linked to other PEs through the use of communication channels. Second, each PE communicates with each other by sending messages, communication isn’t as open like that of a Shared Memory MIMD system. \n", + "\n", + "The multi-CPU systems and multicore systems we introduce next both belong to the MIMD Architectures.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b916c7e6-86ef-4d4c-9553-96fb60630e85", + "metadata": {}, + "source": [ + "## Multi-CPU Systems\n", + "\n", + "A multiple CPU machine is made up of two or more CPUs, sharing system bus, memory and I/O.\n", + "Multiple CPU machines were the original attempt at increasing computational power but since the birth of Multicore machines, most consumer computers have adopted that approach. That being said there is still a purpose for Multiple CPU machines, you will find them in supercomputers, servers, and other nonconsumer equipment that need raw computing power. \n", + "\n", + "Multi-CPU systems can be divided into two types according to different memory systems, one uses a shared memory system, and the other uses a distributed memory system. As shown below:\n", + "\n", + "\n", + "![Multi_CPU_systems_model1](2.png \"topic1\")\n", + "\n", + "On the left is a diagram of a multi-core CPU, where each core has a small local cache, but all cores have direct access to large shared memory. The diagram on the right shows a distributed memory system where multiple CPUs, each with their own local memory, are connected via a high-speed network. Distributed memory systems are common in distributed clusters and can communicate using MPI. Since OpenMP only supports shared memory systems, we won't discuss distributed memory systems here.\n" + ] + }, + { + "cell_type": "markdown", + "id": "e42c56b5-e4fa-43c8-90bc-741e0eff714c", + "metadata": {}, + "source": [ + "## Multicore Systems\n", + "Multicore machines just mean that the computer has “n” number of central processing units. Although these processors have multiple cores they still fit in one CPU slot on a motherboard all using the same power, cooling, and other hardware.\n", + "\n", + "Let's look at a multi-core example as shown below:\n", + "![Multi_CPU_systems_model1](CPU_architecture.png \"topic1\")\n", + "\n", + "Only two cores are shown in this diagram, but real multi-core processors tend to use more cores. Multiple threads can be loaded onto a core for execution.\n", + "Each core has L1 and L2 caches that only it can access, but they share the same memory system. For multi-core systems, the difference from multi-CPU systems is that all processors are on the same chip. The operating system treats each core as a separate processor, and each core can work independently.\n" + ] + }, + { + "cell_type": "markdown", + "id": "8333c793-a6be-48f2-985e-91e55f2cb39b", + "metadata": {}, + "source": [ + "## Comparation of Multi-CPU Systems and Multicore Systems\n", + "Both systems have their own advantages and disadvantages.\n", + "\n", + "**For multi-CPU systems:**\n", + "\n", + "*Advantages*:\n", + "- Multiple processors can work at the same time, and the throughput will be greatly increased.\n", + "- When a processor stops working, other processors can help to complete the work, which greatly improves the reliability of the entire system.\n", + "\n", + "*Disadvantages*:\n", + "- Multiple processors work at the same time, and the coordination between them becomes very complicated.\n", + "- Buses, memory and I/O devices are shared. So if some processor is using some I/O, the other processor has to wait for its turn, which will result in lower throughput.\n", + "- Increased requirements for memory devices. In order to make all processors work efficiently at the same time, we need to have a large main memory, which increases the cost.\n", + "\n", + "**For multi-core systems:**\n", + "\n", + "*Advantages*:\n", + "- Multiple cores are on the same die, which results in higher cache coherence.\n", + "- The core is very energy efficient, so it can get more performance with less power consumption.\n", + "\n", + "*Disadvantages*:\n", + "- We don't get as good performance as a multi-CPU system. For example, if we have two cores on our CPU, we can theoretically get twice the speedup compared to a single core, but in practice we can only get 70-80% of the ideal speedup.\n", + "- Some operating systems do not provide good support for multi-core systems.\n", + "\n", + "But the readers may have noticed that although the two approaches are slightly different in how fast the processors work together and how they access memory, their design is very similar. And the important thing is that the working logic of OpenMP is the same, which is to create multiple threads and allocate them on different cores. Therefore, we treat them as the same.\n" + ] + }, + { + "cell_type": "markdown", + "id": "7c12a2b3-3816-4056-b423-cbdd4ea8b44b", + "metadata": {}, + "source": [ + "## Multithreading\n", + "Next we will introduce a concept that is very important to OpenMP programming - multithreading.\n", + "Multithreading is a technology that implements concurrent execution of multiple threads on software or hardware. Thread is usually a concept at the software level and is the actual operating unit in the operating system process.\n", + "We can divide one huge task into multiple small tasks at the software level and load these tasks on different threads for execution. \n", + "\n", + "The multi-threaded concurrency is a pseudo-concurrency in a single-core CPU, which is just a quick switch between multiple tasks through the scheduling strategy. \n", + "Implementing multithreading on a single-core CPU is essentially an efficient use of CPU core, and try the best to make the CPU core always running at full capacity. The interaction with the memory is dragging down the program's execution speed. Moreover, multithreading can hide part of the interaction time through thread scheduling.\n", + "The hyper-threading technology essentially simulates multiple logical units in one CPU core. It is an optimization of threads based on the premise that each thread in multithreading is not efficiently used to improve efficiency further. \n", + "It is used on Intel's top CPUs to pursue the ultimate efficiency.\n", + "\n", + "The multi-threading in the multi-core CPU is the actual parallel execution of threads. Even if a core is fully occupied, other cores are not affected and can handle thread scheduling. \n", + "When the number of threads is less than the number of CPU cores, only some of the cores will work concurrently. When the number of threads is more than the number of cores, they will be loaded on the cores for execution according to a particular scheduling strategy.\n", + "\n", + "![Multi_CPU_systems_model1](CPU_architecture.png \"topic1\")\n", + "We still use this figure as an example to show the architecture of a multi-core CPU that supports hyper-threading technology，Suppose there are 12 cores in the CPU, and we create 24 threads. Since the CPU shown in the figure supports hyper-threading technology, two threads are loaded into one core for execution, so 24 threads can be executed simultaneously. If we have 48 threads, 24 will be executed first and the others will be queued. Whenever a core completes its current task, the first two threads in the queue are loaded onto that core for execution.\n", + "The cache in the CPU is an essential part of ensuring that threads can access data at high speed.\n", + "There are two types of L1 caches which are L1i, which stores instructions, and L1d, which stores data.\n", + "Different threads in the same core share the L1 and L2 cache, and different cores communicate through the L3 cache. The same thread can only run on one CPU core at one time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21a31557-bbd2-40bf-af60-1067763388cd", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/src/MultiCoreMultiCPU/2.png b/src/MultiCoreMultiCPU/2.png new file mode 100644 index 0000000000000000000000000000000000000000..1abce76a4c60b57a8766ee59dac33368bd7c6d12 GIT binary patch literal 44507 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 Kr5XkE@c#$+>SM_O literal 0 HcmV?d00001 diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb index e56cc09..70131d3 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb @@ -7,6 +7,14 @@ "source": [ "# Creating SPMD parallelism using OpenMP parallel and teams directive" ] + }, + { + "cell_type": "markdown", + "id": "80396b0a-815f-4004-b29a-b53a47db1c15", + "metadata": {}, + "source": [ + "## \n" + ] } ], "metadata": { diff --git a/src/MultiCoreMultiCPU/CPU_architecture.png b/src/MultiCoreMultiCPU/CPU_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..32a4ecac3380718fcab71ec6e8c945e75520bb20 GIT binary patch literal 54548 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 A8~^|S literal 0 HcmV?d00001 diff --git a/src/MulticoreMultiCPU.md b/src/MulticoreMultiCPU.md index e3985d1..8738b0f 100644 --- a/src/MulticoreMultiCPU.md +++ b/src/MulticoreMultiCPU.md @@ -1,3 +1,5 @@ # Parallel Programming for Multicore and Multi-CPU Machines -In this section, we will introduce ..... \ No newline at end of file +Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. + +In this book, we will be discussing multicore and multi CPU machines and how they work, how to use them, and how to optimize your code to use them effectively. \ No newline at end of file diff --git a/src/_config.yml b/src/_config.yml index c8a7379..a95e461 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -24,7 +24,7 @@ bibtex_bibfiles: # Information about where the book exists on the web repository: - url: https://github.com/passlab/OpenMPProgrammingBook # Online location of your book + url: https://github.com/XinyaoYI/OpenMPProgrammingBookTest # Online location of your book path_to_book: src # Optional path to your book, relative to the repository root branch: main # Which branch of the repository should be used when creating links (optional) diff --git a/src/_toc.yml b/src/_toc.yml index 0d65c3f..c61490b 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -8,6 +8,8 @@ chapters: - file: openmpIntro sections: - file: openmp_c/1_IntroductionOfOpenMP.ipynb + - file: openmp_c/2_Syntax.ipynb + - file: openmp_c/3_performance.ipynb - file: MulticoreMultiCPU sections: - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb diff --git a/src/openmpIntro.md b/src/openmpIntro.md index a034584..82310a8 100644 --- a/src/openmpIntro.md +++ b/src/openmpIntro.md @@ -1,4 +1 @@ # OpenMP - -In this section, we will introduce what is OpenMP, give an example of OpenMP. -Then we will discuss 3 areas of implementations=which will be introduced in 3 big sections. \ No newline at end of file diff --git a/src/openmp_c/0_13209261094r4F.png b/src/openmp_c/0_13209261094r4F.png new file mode 100644 index 0000000000000000000000000000000000000000..1b7af26f83ea418ee269fae4f649b866e113f622 GIT binary patch literal 11310 zcmb7~2UJsEyXGl^G(n_`6zS4M5Gm3FB3*isNN*}gkxoFVL8J;&Lz6BYQCbiLL~7_A zLk%?up#_r6@%#RF?%cVvX3ek`Bq8VQz0W@TywCgoo*ieXuXT;;CKVA8(KYQy8c&Fb zi1EPtDhd+dFO#CBJn(YGMO9Cgh^Q`+`qGXJ_)O{b$kK<1h_?IhFL9q|nIjRA$f&l4 zs!4$DUM|6tX*!dD=BoXi20JaiB%8-^wQLJNj!g}pClPrR%Pw+_Z}f?UFmGkRPGYk#H4mIW~9b?JagBtx*fw#X&oDvh~+aIQkx8uK=Hp8z1yDwM*;srnP2;NTfZ#xtx$x+ z0SS+$cyQ=a#pGBReiMJ#!vZ#x(urFyDjC?`sNl~PD=+c6|8(^|lbUi%1mg6SCkp1h z{y8ctO2L0W*!^~t(NoW4we0FcoJdo(;y)44py+Fq+}`VV(nEpt2@7G){qqvuBHl`*V8J7S0;$%-3K|qIw zhF+z;_22?aXq5_lj-Q+9N{}UBkk(|_kRXrkjSs4C!z=>{zeZt%OBYYFq|_~1PQ?KH z<@xNaIuTp%*9Z!Kc_!%lFEg z61XlCBDu`>E+ylo2JoX{g#{K`BaJk{hnqQ~kVS}ykQxZ`D=&99%=u_zNSSax zGVmSSS(!u??);8U>5O~c%4Z;5?CsmPHE_JV7(X;j&^s>NG;;WTNJ$ot2}VJrch};y zFV^XPC%$+te=QrMdc{l*YPY9UO%PV+;KxHU@vq32gFiEWoD40_7 z#o{d6m=qLWyp`L#cl7AYFs_0k*WC~V2?DVcL@Ktu952zs;c!kM!q0;ZhrTdBWLH%D zDGTs@W+g?cd^}XLeVasQ)Oks|j=(l*AQ-{WEs{#rGSp1yKS5s}T(vHnjE;#h$a(O+ zmD+@;Y3{4>b0$|Ll-x$H01QGE4?>}a3`%bK@QE&RtpDDejI^`{TD~K2e}8KW*;id% z?EXi zCCnPWYa?K6SjvPgjzL+yj`sF;6y-}b!U?!6@4hnOg(_hRT@w(}#Nn_T!pR3d-C!@+Y@(4ARvfB5imj(;7yP=OMYYyiFjVqDSFw!HRSBTZXr>U4a*?m zDbiK{Vg1uJW!#_bY8Tn?izbihL%oEax6})zS7}+uPW$@$1O?fM)Pv88C%-{!5n@(? zY6;l!?Qg6Xn`?fgq@*#l96Yy`?%(f~y(?uvWJ10MnS&rrxwnPIBetnvKPb=1v5wVc zy1t#^HhdmbqYT&c`ykHEmzrcp(V0{p~{K zz{9nlKPg@?1#oY1bd)#q^>;U^T%IlkC+g#-Yry81(u}_Yk^lzu&&|$hdtY{b_Gi@# zmWMt_ezm}wws8uwaCUa)zWAh*@gVTllRT?p(6kCHBY=g4g{^h3H-R0B$4HseV-<@& z0qd~T+?W3G&ygL99AY8F-R>kxAXJ|&*+#?HMO}ec#1GXcavHq z^gqr3Exn5F6W_?A+fyPH&&#~KyS~#b6o?0X6|Hs zQR5m`J`Gwh(7~{qsER-CCOs$X7RHJp5({cSejN6Yj?-bpr8n$a#&ARNg{ljCAr9xC zY+0OVEXL2v_zFZ$Xdu|?vgsbHF%h)}CCP)nq?poAmMs;MTY6Pn?`Ephlm7Lj;W?GI z{h(pZWnE!47GZG|n;ZMzgZhuo@`!G_k5?RsO!+3f(zKy?!Zc2{ZQQp5F(fXVzJuMn zz5m5Y6s{4u1VTtm#meLsDklpt;leQHLpw@vmdVN=y*oF@>0cqtqQ)4NJm0OG|1NTI ztoa}nS-k~fbuE0rk^bE`&I`S0fk11)uUJL|5}qh|NDLFQzGIbvD8FUJGV^`7M5l22 z!7K4nl*^Uf-?CKgUBPF_Wo_fYEnvwJKcH%IC=9RUvAv4w*;(`1*)tDl zFkjj`?3nz78hN}Gr{OvcYCpLAr4cz(QO9KhTuQ+Br{qtXxbH>~o*IQf%%n(a-$qS> z*h0XO0au4<{zz$a$xB-{j2`19{=;pyrXdre`>0d$(xM_R-d{;Cb9H>InL}x4WNYHT z@V%;(-g|t{GoXeO&Cq=VE-Vf_I!{!Eu^DYb3DZsIw{~8Z%0jkSN=S$-=z0AgH#XHC z$St17H53~wQ;39S@sv08d@;S>VeU%*MzmmgPrUiu_Jl_oWpLw->jat`NwROx&?4?Z zPTAiZ)K(|X(Yxd6L(ujKS_$^wUx-st?!POnPh#ruaEezwZ0I;<11n~M_TV$57iZ)9 zJ2?{EeH{97_lLGO{B(QrqCZE?WY{qCp7rTZs&QP$V_y>0Rvhp=8RJwE?vhN5WwJZ` zyYxB{B>O20*v$O8>u0Z(`nP;qmveLN@aYy9!S80Ec6|`4q+5fhkyaI0-4V?j*ztFB z5a)ku!b|s;gm%qnSuTYWk&>Iv&aVXyo?uGp0uEK+P)Y4U`cbuE6P*uP5|0ota;(mx z$w5m;M+YDe^RU&p;RC^W_)$04^8zz=PEO~pC7;b6Wk2w(CcJE!J~ z9V>P3-@hLo9`@Urda>~J)#h+6puR;#MWy<=JO}0&!Q<-QJs&966o?YVD?sD}DUZxu zoT3G#l|s%WF@n0$_#XrF(Awutfo|OfkhYec*=xVU_U4*Gj2(UvaTN^@WXJ>(W%%j-EgoHnO?*8e>Qw0s)zk4@orYfTn6yv!qrhVuob{)ovJ32c0mqGwnxseZO z;1Aq(hk2P1w-7E6GA7bO!M~R5{2}7jzf|JS-h4AzS{0*x#I9uSHZ;g1C@8D)ceYqgs=jh#%Y6SYxgceyHagyY$xGA9*?01xB7VB8XwXNz>b2}Ys- zo@MJ&%>=)8tRBq1^IG~r9J?yJ@8WTTSjYv9|rUj&|g(2TUti9}cj>Tc#6fCx9R zBKv-B_NFqq?W>?7m^Vr3*W~in$BB4po*xhTi)2CYcJKJMPeHjyi^k(}*~85ak^Jop z^%p{1a(&ND&zQ3PbUELc^!P?>PnN+sk1MC;uG+Y_Xf(Y6;`g^*AE$s>qkQE;GKUyt#{k5`^cvJJLYo8)5!Xg3+!+aii-3KJl zYd^!~tlxsPH%mMaVZ1EolLEZVl?5;UD2a zSLibR6J17cCO@)l-&b~T`co6SH^gH56`Q>*S@$5sZt45rd6UaXUVY&*>-GJ6{tg=@ z_ZocvJo*C;4c+^FI}`R6D)~t}n^#TXfrtpUC!B$BIilMJEutr;#(6k)4s80lcr-PD zFXoVwl@PfHKXbNN#BI1U`f|2(Kjz87$;ruo#e~6#Gs|!b-+UhZyz_+$gL4vlZqhHT zW2oo$ZOrd8bcn@BT&vvH zIA3fPpK?8XsNr4n+V4-`ITzk;BugghY!|=p|2^NWo{6SoVs>_M@fvv?4NxOL@;K>< zXW87?c)8r6_ZzIGeB24h^~}u7!NEcG(^kVVpOJ^Bx~k0A2?iV-0pSsNheXAC@AY4Q zb#|_?yt&yQ2Hz zqnThpp*}7I4U8Jt#FC7_loRLrSAfnr!o!EvM6a`tveVS#&!Bzs3JQN-2GFKGyNF{D zq`2%4kz~9v16EVkRrK3tB$m24_vOVrP|r}m`kv!xZaz&2T%nA^z-;OYi;771)pf%> zttJwu6W+bc{|MCfAI8Gow-PzFaEu~;oml}+GnE_2Bc|FNx8Q4 z(ZmU0ET5YdrxWqcF4}QPge1X$s>f|Mv1Ins9D(!q1D_yohkLGsT6|}Cw}u6((u{TN z7P8^%*I2Z6LLc*$+MluUo`fhJlKo;|)WX#Cw4m+}s)c(bUhbY_){3iMZs*4b1tn`L ziuVxLsd#kURBnDh+(#Ot=fHvVzg%-W=(_2()IJYOFxh$UOH5{s4ZSm=yQ9TOfh#R3 z`H@T+^=c2e8P<;|Q00}+xRrjag|Lytq6~!E8qwT8| z5o)3feEYZ9D0yCr=YjG<&XX&-3yU4-64-p*p!?J4UB4Ogxf_xkB*LGFcZO<{bBjnm z_a)wD&=EV57k2)pD%@3@{D!1-A4~Px4^v4oUc^O|Lg2nqK&z7a0I0J&Yp+vRy^U0? zAqt{gK;E|D;rqZT{#7zVGmVfBRt~+0!k=*ximaaTigVgC+ZPDGMNhbOX2h3<@nQwW zVgOWO^K>^pZP>Pt^y;2q4v|;d570Rc>&1PWkH=koc{Wqu7?230E-3b!;}2(dJ+>(4 z$%-ARn@$0{aLnTj=yj|hjcR&a(iy2#p}N}j+qd^^(#WQ?@5$uHL`o)kR#dB?2E3je zN8F0U^WpwHtj-~0V6;y*tiy|=aDp=8c~MNiMIwq-mYvTSU20Y%l7BH5`Ow~~OCx{B z5vKB>N9%zTzA@+76@%1g#Vb6F0dd57tkk$qQWTWW;WyQ54|#qlQL0~uTt*CoBFmEf zy47E8zqajcN;2dewJf9IPLUWpeeY<)^=+KSi;l+$iH)ykwFrNjH*FzF9DSg+>^-XC zQj>~=MS?#`=i`3*y9`fk4%P)=X;~%Aeam=!)#1?Vll(NQY9Q2P0llL_&Bt2pZ6an$ zb-kcI>d+I6G-kQZlR!pZ;~B{hM6xtN{eotHr!&*&@8-*WuNQ z2(Rmuvg^nlIL{8GrV=e$8U&$^sYjP5duEL79FS=d;QQo_EOulFwB8b{!+lMx?b9aF zZTRJ=x~tqn?4C~Shxhq#cUu>SPK$BVTe$o8bs3MxXFOIyvxjq?x!VfO3+dB=^JRc^ zP;EYPWRsd2mLu0aC{raFcazI(=DY}LH+7yNx7JrwR8P#F%{63usb4GsZ^-x|S@n@? zR_C=W{AYSd@pW`viml*$-{U^rohsYSd!AKWK!N|}T~o2_&ZAm`y2c!HJFAnw$;tsCN!56KY;!+{K}cy zth;=}k~8JjyPcyCH)5+KNi&c9=8C}b=4I1?dN0s^uf@&3L?*V2I*4s~c%^jY>EbN+ zBNG#d9rQ|3&3B7tdzo=J3K&9-uh!~k+48)aav|)aRTSY3_T2kVOU;s&?OMW@SdJT7 zC&bgV7rA%5q2xHPp+@6BUtDyg{?lN=wPQ@$~l1qSqh#H9$| zD)__bq-|u@L7h>N7?x~ZwCa(}Gm4jZvhS29PAR_U$;wfSms>hl`q58HOm0tHPgzRV zqCy|3K1R*wgWJW`#OrMR2_2KlV;nt~Y&f1LOi~j{m73OLt#|LIQGMt$Jbzg10WVa} zCtld!Y7j1=_T76vYS1Wd`sT_mIqr?0=Wrk2i<<~^Ys8b*0NIA}UpW9v*?iuzRx{?> z31KU(}>OZ+r)p6!GI17SzEA%6lEj4v*~UbA}%OTB|$vaG;i5x*U)3WI`Qn zeJ;;7C%=YuTE~f~cNoDA@8#0So2~d8hRTnOqzHFK-sz)~Nxjl#hVYzCtxgylhe+=a%Spgf@dxxn7I3Y7tcO z8^6fhkgn@zBgkACjIC~9&u@J5HC#cV8{-0yOnQC&KQVxwp2}<+NNm1IONyEPo0P!e z@G2A++fvBxOpRlTfpfVTKssBXlI0C$6yue{?U~cEpC3nu?(tSXUfN4RE=gH>AO3?n z{yPcJL|Z!tR!{ck+KcF&DUQ}aM{UoAyL7*@n8liQ^~rvQ77|2A@@{W010;ELbQH(| z&o;ibmX^kFwYIe6-RU~SV2>qU*Bl0|{x=woJNREe*}`%ujEO;?^CNWQg!12G4)lNoaw0LAsWe{cUa>fj)Fhm-(Ed0>2C(o zF~E=TV!$>N)Q%g^&poNJ&0&z9RT0h|6biMwYt#I45lET$2N=#)VEh`%|7f}K6#`XLPw|vXlL?oMIyEa#2}=eKJ{MDDV8sR#dJM1G zG1Oie-cjpcTK;so!51VuKYiGAa6-W;#)+tBrItXq& zAz_$~IKP&E4U5G0)wBz&Hk}JRqs*QL3AiOgf9RqoZ(&ORv_wQisK?MIU*}?HU(IIC z6eJQRJyhO!V}|6ECn>vIf_7O-1kW`v_BLL>u7v;sY4Eq z{}>)cxIetZGoM|M?G(}spqZ6BS8I5iN&kP*4g=!q>CUOrz0C3}>wQVj4g4-9Een@_ zT)bKU*B3)a|5cVJgxwj*-n(nb%T^=iWy=B<8ymENv*5Jb{}+$o|B?S_N@F8B90mCX z%`sPlKJa6EQgjDBl6$I;bU>&9>A5HXXork)-6z(WX%pYLqpGiUh#yMCa?QTRD~_CfMtm%uanAF{wKrZyZE3`?eB?{fhcr7!TY z{r|v|>hApqPa>?uORyTt-n3XE0;f2Si2^85v#(x5Igm3?X*Sna`GsH|%A7u^=-OYN z&lMB4+$fxmDxK)0w0LwDIkaORJ3{^$id}50&gZ3j>nAMSi^`B!VV(+AKbbFr<>f|J zhDa6_F01vu^aW_uaq%m6+O}4HavVb{&0B=>Us*9-6p`z9-gsCO zABsG&wj#GNJ^BwEMXelk%_A|4RCHYAZj}xXn|quowUx&l^~h4nQU|%c?ADrk)J@Ja zmOQZ3Lz~C+*ilcGH;hZZFL~11pCe!!tS{<4c`)Wbb_PGwpHjCP$Bm-*+)5vYga{&Xt)-BdbR861RwjW|Fj)*xj zr8%iBfM+9xgb8@w-ws3RAt_ifE1VOX_-}X|n$F&JVY&0U%Yle4B;-t4KZ>oN5>4)v)v|OB_xIz1?w8&lJT%?6cE0u zE6(8e06^!1{7O2o%pu4$+zZ1DS00Kx{bv6_B^sOvU3vnjG}pgXS_=Vo!;l93kw0Gu zx?qa-K1x_DNk~1}XKejc2uElLcUjD?)kPF4lVV_s*zFJf4oB0y%rD!{OX-${M>of< zjb&?SZej+0U6@BZehj_CD1vS}GbZa-&hQK7OJHj}+3%~p_wzr%lXm;(f{ePHMYk{m=aC*eyqRy{H5)&d~nSGCBPJz3fd{0bU+ZR|LQyo?3(_= z(g7tmM8HgPpm-D1a-*9u1Ol-{C`+}S&(wjRe)U4G^u!O&RHF>GpAMmDJWllXLfHwB9RP&`Z)^z@2T?5*!_>|G>y$0eL$Q> zz}cqhOiTrZ%Ip~QT$6{ZE2=YsG~{SuaeVx($m{>=D>VN%Utuo>@D=RH7aLqggt7DY zf#P2t0R|i@1W4$1X*hKaue4IY0rzs_m*bNYDddBNNc2V5m2DS~cgel}5{8af`qk9?aKP}lVO-$i;)3Nk{urk$ov9cbr@CJN z{?~=yJXSDaBU|7v4flBV>^A@w_D_MQo7Zcv8*3cobCkN_CPr|Oj(Wz}UBWfW)s zX+Jmq=?H}w0jWn~tiQMvAH+-XsD=!T5Rxo^WUGDDPyD~DM|GWPj5`-BU83Dt? zo+8k{p8*U7SU$%JLdFOfGfrcuFOe(e0uvIG=;Pzl(9i&v=#sj3k92mcslVUYsNXog z5p@%FbOXJzveMPnmB22`h@+*Qx&@T?xu_aS7zRiIDFYQf7`%{vSB8nwP-iE5^CXYW zsOnT+f7JH_waYwwIAnS-BtOkFnqe1mHWhJ83i0)?1#S|V`AEd=_RZtc1gsl1|C5gY zgA|mD{D&0$+gkYeUXbqn&)X^P&9U>F?m%kYH3Kff^I#1ReNF;6Y6RMiDsjP|UvJCf) z;YwpIZ>uo{$cVd#`L6E=xo;GEmRC;e4~on+NknCy@=Q}LSctL3hB4U%x$%n?sG$VE z@Q*xV-#tIt+=6IBLZps=XUm$yv%Tyxu)#vvvj1-C$%B|jL8Nnz7k}ODZ{=I{Eqd<# z6gm|Y4Jny=a=?}$BQfn4S<+i?0x>9~LcdPE8T~QxSV60qD2~}&H6bX;o%Alb$OHs+ zb3&GQrFBWV@0a4N;aT4Z1v6@#uAJIEfjuaV4pBYjjGb(M&>TC1*lySRUH#jPpa@1C zB)=v+OPrxk{kFTdED%l?cA3AJM~xa#W$TL6$w>$id#L%{kSX4BEB3RPNnX4YStyib ze53E-4eZ=*)0ysWZ-JynJ`sn3G$Wo)$Yh!?9-!X!m(IzmndGYvL2 zpmTDixlS#Bhx=uHd{}UncC&(YG40Cv(L$8L}f zaN$sNADYyEL{(B8nMDCH4L(TngT#;$^Oo;xO|ly&=g$VlFY8AK-SF-?z+&Efm9~;z z&hxyh-IyNmku6p1iLaex{|>&T_L;-gMMlSGO;F3oBlz>vMH|R~A2+hL@vfIt)zL23 z9;HB7|D>I$fdE3TabYfQ_=_8R^Ma^wSIOeeYlWmjxYM05?Ke7wlyr``?B$$WqC zacV$vH28~U)3!X9C$FTQPa_RO!4VR?RH73YQc|>Z+HuNBu-A!0IXNgTl|-S!<9+h4 zyhd7-th#ATczUbe%H`1W&+7DkAmYQ6BfNv4!!wF!==LvFrOB10b&{ts&*-H$tOPZs zCXT>NBMU`i&xM5ff&J&Olh*pbGe*1_aag$}RNxUDD# zU^ggqXmbsuv1Co&zHdF{BClcP3L9Cq(z+q-EUxacniwC-!|k^d785FmrHUONkCF*l z)HJ(yL?vqOv-JAVnZqrn0$}+rlTcq*jXxxr=UWHc zs<9PjKGU0v2zA6nj3gx&62Y{y03b6L+0LauNsNnFKNBBSw2;=s3FtVyOgR<4Q2_fj zxYl9iH877(5>~6pD5uD-8Wq;W+1qP7UD?RhYZJ8&vfHFKq7C6tT4|=4M&+|M^sWLw7 zd%A4ps?GOS{iRq;=YI3i;2g)QM|wICNw|D zlh%kSfRScudJe08)udbAZhX$vLL+VeLin5%7L{I#S$CD|ogW2<}2 z{g5Hj2o3Rs-}fd-ze;aCb&E^L|BT_48X^@qP7~VRyl%ICAkh^#uK7akqBoMx8rxFl zZC`S?TWK38f3UAb0m-wMWwP7wdt0c?h!YrnxqBfYR-G=Z9&JyzqsM6U$jsrZY&!2} z#-$yoYo1I;pKU~q>dcHP0v!$P4w!y9)~^S0U42zIFNAd%^YYov%0PT)hVD&4 zxCfxms*teLPf`4p6xObnK~n`yF`h`oCuDMQ%;FM!&o*#jNqmw353j?v^oC z=A0}`W=<6prjcUwj-L>TJq2w-BTD|uDHkTAZ?pa^PP8EsFz4&4X>(jg#SqBKLQNOw1gbW2M&h%j`+&?PZL$j}`FjCA*V z_4EC$_0B&m=FVOB+;g7uJp0*upYZpp^7y!vxM*l-_=*ZL>S$;fIcR7PW^u59Z>ZN8 zC4fJe&Qgk+IKamT=W`hF|1%d^T^9{|GZ*)dPNrz)cJ{WWoX#drrlxkz7WOXt813R{ zXtZdGGH*0JGX6lpQA|^w$V*XW4)-D7(!s&mb9VJ!*#d>ZyySX5rxyH{{@1*F4~m{s zz;k%M^jBbQh*ODc(UaDa~->|F7aNb;z zF=Hx;=g=$AWrROb$T?a}cVx)7>kIeySvtRul(?O+ZyKj0L)sm;-`U@bqO~8Q+F@(& z#8ja(Qu0Lm^7Mr0L4*>A2DF4YK4h0E_eaKe1{LWS#asdWw3x6a?>n*PrdU{j=J4$p z1I_u%hv)$vp@S8-vlR~xervq*9riw2IjFdsY`UZ zU$B8&uq5^`E5G|@x$H~yoXjau*+#T@@A@>mw%dSn;+YqQmY~QpUP2s9aSm}#WW&3m zeWHt#yuw5Ukdz%!jyi3DjJEMUOYQQ%r^oKK_{&rum;Pv!1E0KCUvl1U)St71u)TN0 zPk@X|+-FPd8R7xM=~(JqC||$`@D9&bf54V%#dT?6FP~!e}YAQYdm^LSpTQ< zHKTZE_M9Ml4!hmQA%aYuyLW@V8Z^gQ|KrF1MxmS3~NZ9z?=*v;t6Knpb z&01gVR9-y#iiQt7>HPRO`^m%J$^EMFCPmvN3Ffpr($Dif!hwY6eTLRZ4xHeTx%DZ3 z$^Bvf90RZ7+4gs^KUV*i=+P81z&o=gjqtYY*(mM5A(D6E3DtN+oUxSWQS_JtznVt{ zp^iJCFmF8vL5a%M;)Z3c2b6#3Tk`M4^#3lBJ@7(yLeP0}M*n{M_u}#*OGMt^1wkIZ zY*eMM7czUq){0S1n69d)Z!Q^#X9xVQHD#?o*7@pWJJwrJd`74r(UPm586ar#art${ zgYztf$!woHJNvbp>0j@BQ|FFm&&7`y--hyY1JBh5iMX&fE@SO^idW*<{rDFc?~bDF zeFAID;p!y4{m>WL27A>-LgoPw>$o|3O)48J?frSw&65S!W0)Fk8m)MtMC=YFyKzWd&- z*Ly8*!tT%;m2^cqz=W&Nuj7#&oL!@(zc?lCd4G`nm`eF{EWdA|-5~38x6T^jj2^_G zDS;8t0hJ<=1;!s%;eU%79v=3YZ+VJylX*izKL7r~-vxa#2+I_`Tv)nY_&YI@jdh5as@L6@hV2b*06!TWle*WT6-1i7 z3JhK-i`SD+MhYRrT!O}N!LKc&nIe93ZCw0Yz5`3Cr4koA&y$zJIqB}{Ge2Vfx3b0= zdBZ#i;$9xa8!%-QTNQ#nqeCRJrp;fQmb>p8xv=cV4vIX+K8o(~Rk28C=XFoFsq-qt z*Qy@H;pGFIZj-fwQ!^$Ntqn9TH6@SElFv+<8=LSJtA!U)bTOw~yA(idOVS=#u9Wj| zNQh#e#C*U<=ldHq?W}4bhK&3H=UHnM2PbD`TeDKdQa*GxcW$?`wzlVL2iG%8Bbn)z zg8`0rl$XPScXcbis~YOopd5#kIE6BP6?*$)%KEo8f4qy|ajHX>(w#ufb(#Ep$G}3}F=idSqao`0VpuWsGwUMJo zjDN6IEFMr(A48pnuZ1x}Y+>d~kgC3Tcke{gPOpY{?Q@%hy^*cQu(=FT_pG`}t?Hlg zspii-<1~_soM_?;qOla?xdnJS2M!2LOrG*ly4E5JEF%y^U_|kvg}Sna3ki{>Y(~*K zSPlVK(BLAhDSMY}zIdyx5LI&`V(4{Cjs7Ofd>yRHg{rErS1q0}vo#G?ZRn0p7yK33 zB_GEon^q)t{HI1nO$B7RGr~MqTs%|b{iHvJ%Jllgtw5c^x@2;PQ8A)}&Oylh#gw7H zO_H`>pOz*HQl)FIb_C_@_?OUpC>u*35$XTT%SHd2vl2-W_VV<9MhFkULJKh!-;x{*49i^-r1Ymczmat;01|zMP+)QuLen?a3D~%c+wmf8Hpj* zevtq! z_~tiTFi7aCno}#c9X6iW*38Bzg`23Z0Ev@YEqkLJJWgq%G>byj>gWtqN4XWhl^FVU z6lK&fG&oB+Rc^GgIRbuZ*c`=%@0eEU+|PGTCEj%sW68{1JYD7eL}RWY-&H2SzQML$ zPl1gGv09cpw~xU+YUTU*{`$Xw;Ikph(Wiz+@{Db2{0BhH(UBl2C3?0}+#iQTsW{af z-NOCjU1BI}Yl9}Iq#<%Hha-q!lOsyNy0p{+@(cv}G&QVRn`pDt6lf^w&I2{UK9ze) zWtrj1N@cIDTd2M+`=(;9TO`soMkvBpMmc$<>{v^KZd7f(*L3@QV&&lv1d)_3p-8EdKL*&DNy zLmU-l)vc{6YLq+CBG+eoCjBwb+;(S2Mh^(pmGbm7CuMBY6hGnIw6QvY2Y}@$R28SJSi?paxY@8!e5W>82?I~zjt6-sDDr5O~n)w z{8e&FN~7BbdrgBKw?zBE0fAbF`S<`>+(5z4fD%PsgBU)ChBJEQpe+bfwzpK;=OM7N&T+a z;k1d0{n8t2kMCYkAfTh7V&V`e5>L5`rBi}t$t>iFh_I4%83rAR5^hAbq;{Wt5yyiq zq_CwP29vIl-g<9}k(4}TAwO@+*>Z;Tqi|BJLi)1PPZN597>P%ona_=|orcm_3J$s^ zMSd7@6-d5_*7yL)pD;qs&$w@!`kEEFbMw^UW1n0>nX>bazBTas;O8il|7_lS^i+@7^jScJ8z!o zw_aVLGG4n=vtW)O&_eemV4cwG?=w{iUNwq(_TLKF)TI_t8i@}xo94EJ`pAUU6$`%U zS}P`yd`mP1YrS~ksGIu0wl-T}$8|}{+E6P%^Yd+#o?iZ>)!1%rDfnFgn=+SVp$x46 zet20Og-KjnZ)i1fgOp@^5ruWtm-mamf9Ri3fIu>dOxDWBKIh&`h2RQa9s#8?CUsn= zoP}L=YebdQ2TmbtHZQ{{HZ{G#Kn_%X{`c_R309^V?+YAH2@^-Zm}4Z&aqWy_s={Dx z^N%geuyG)gtF0@+99C^&7IIBVWne8ahA+82{@6G-3$9wz9@u2>&|UVIR?sWK}P#D0f=BdTZpf_blsfEVj|> zR^-$y0Vo(C5x1z<-si8NCRl_g-ml{s-zcyix7kN>4q3gN7%iK8e=5?K_!&y=NFrUx zKj9Uf$I5LQ{ted}zo_hI3IQRywNgau2M>?Lej0CdwvRTS;#-|2Ngbuq5Ufh=RAAXO z8wzY;>oGko=c0JIn(#V==z`vo8y+puZ)_|!cJl?*mXX1uSGRVta`9iBwLV8k%BIPc z27imEhi|#f%EXcT)#*`{Fy0zvYg?lQw4g9go_MCMz5+4nFqvu~^h$z1NFlWJ7?fhY26ON$hbE@r|luR0JWA ze`9XGW_~irqV(eNKY%C>RbYFOKx2#_{fQNSzRfRb-xtZInk_yO9GNn3oblTGtkVD9 z?`(ewe(_rX^fiyqqHr`W8~>reF$a)kZ^f;xOD(9zEPijhHqSTu1=mgThseuOfGG3E zC=Vv3Iw+Of=L%VU=O7VGk;l$1BDNtRA*s^>vXD)r`15G2%rlW&qgb&av?T!pGA1>W z+(bDgMQ^BboN14x5~x^4Ey&r(r@VrrrnXVW5?_f;E<}F1-XsJ-XWqWiVyKBdH%B2{ zYcLpW=J_$8b}|9l2Zzxo(S~dEu@nPQWBu3^yy%F~x|^Q1BG9r5CW{Z~ zd_(QIt`@W8E}^U(nc;uVf#fn=j}}~7A1{pjGuIMo?{}Q;bB7n3P{bDeZJFbiLte?4 zR8@m!clGV}t}D>r5cE!H>8lKS_AiIoe1N#8MaPqvKYmea-FmXNe>~-XEtnzU9W$vK z+Kv6>=pgXPxK*8nKzfv_jkLm2pB1EY*{4_SN-esYm7RPlXs)KF^%9ZJs5pGEOo$g5 znIYjHqgpHt)i!sUBax2W}#9N^&eL7po?*ygz_Ot&ho!LqNkOHP3&aJK#6azLg+SnolE3VH?DjMLe&g)2abAHWw^q7uOG3`@yc3o7G4C;H`nTUP1c<;`v2yxhI z*sot~Zo8Cgvvto~Z(+~u;3EJi?jz5>d8K4+2ZtZ;SXYeip8?Ti@>nfxbm(fn%{8*& zr@$m|8&KmLeNklgt(RmdRO#c#k1MU0{3?web8!s+z0Kt9FBp}mL(zIy@A1uYsKjSC zw`93|Md(<;vtka8mky{a*G=T+GaBkbqYAnt#urXX)^Wg;Fp*m7$)i`aAH9~bdi~VDAhXfo`6{28WpgHh!VLGV~9z!M!hO682 zrB2sp>gB`M>uvwcLlYWQv(~$UBX16A?s+6`=Gr#|{ZTZ>7ZqZiCuf%Q5Q~b2I3=}; zDK++gNtM=N|A?A={;kx*zn!G`Qz2xd*Cj5O_%+AU?V@|5%Lco~T#?6CZm6)=2~M3^ z0;4Khbneo=S~8Q8c9D3}KxF>s8hUm#Dof0~pFNMFsz^LxA4+=}V#Nnj+OPQgn3+A1 z5J8WflHx{(OJdcI01WKZ`Fbh{ziuc$u*3T>o`?-}Vqja~Kd$B$3}wTI`q7k-w470W zw(%hjS{@G`I=OyL8O?laL|({n1(s`{`}oN!qN>VK1ZCZNv5Ggm*gSHW-+wV%amRjr zP9yW;*9$J_KttQ9xj~Ct((@X@i@~Wj*!~U7e<+em44!>=naw+DbyRA6jV*RFU?QW| z)3Tqjxow{H(bP046xdn~{@3lFJ~)Iar*Iu+wqL!phn_M^`0WW(o-$vb(Hxk`=rORH zFz$1gh0$-hxAZs$ji=G0^6B3$o`XxTpHQz19KsJbQ5A>7PwtX8>iF-LpWJ;R&${Qi zKXJc%PJMC1z-Xz|zSJ+wIuy^SD8Bea`!7^Nmk2)BloZ4?{V(RigBF!^3~*l^9$|0-ZnKiWA6#dJ}`+pm3t!ZMnb# z4#t?Mt5Rd1>6F*SY5$pNkL7xOX<&M&Jsm?=4BbB3n|19Gck znb9M5cJUPS+AAZxL@`K{(=yZ(T`T38dqa1DrO^rM+W$i}b&KJuMvOI1gqf}G~i`l%-sFovRA&x8KvcRTk zdM!G1cZ?k9D&L;|ULsKxb(Mw5vCg+!M9S zTYEop-)lcSa@@<(4zMe%o^cEh*JT6ZiGw^_5p4Yz^10oEFrQs(H{?& zhB)cg=|Y(P?u4dwaNEo-ebOgS&s6t!+3ON_hct(X)SAan@Q(-bW1Y4}iR$5hWN_Yq z$-d9GbS@I55ccmBx5c_HN4Y0z=`j>`JPVAE$GCp-iXR$CkE*E_dguHhj6pu;sPB1& z^V!WqvJ^6&A{m^@zMRC(trdnp(@jqg9GRhhv0`w=JPHU2P~gt?X1c5L_reZeU+p^|jZArLY>-%&boQ7Wp3Nx-7z=F3x95U8hpr60PH%JFZWZhZk;$&gio z&iu3vmQ;|1YIg&imY-ZI`H6^adzR+cAFQ~TF^os(?BVozLWg$EQ0fJ@bid?}(b7F1 zl%(6IOueS;sC^FJz@XPJS(e0p-JVmKfAaY%_%8D^u*lHsvufLGzQAq<4z8E4goI?; zr`CE?jMpK8OFgN?D2`yBL|Mi7qTeXjRiQr0npEWoXRW9R+M!p;I>`@&{I`k0MwQLY z5p2qpF?}6qs9ga|sNAf@a#=UohIhZAU-{bhTndEedmdwi2^Mzf#e6t+YF1X!5KQ%*IDOeqsv}B~RuF?%4;{kegeeY%C|F8&OZhlza zpPJgr0ga_Q-nLtE|ISsf^w-zt$HqQu>3?RSDMD|z&zr?{G?cjN#kVXMS46FRCLYIW z%Ser4fDk%M8HIcgt0GHdD8mVJ63>X((3PwyD5(K@j$iy~t+xHB72jA~9*3`uQaodi z+VIwZ5QcQOL9@X9zwMKL%e zpSod}@BvL3B3VW;S}ePm1FztlOjS8YxVtoHxaXhgs+wpK*wldi) zzcX{=1fx71y{rZYTU`-ES$67N02`;IURhpY0BW6eMLSHnqD|?@{*M3tPxh_*pV@|N zA;d|wcr#%^ors#LAIZP2tG^f9t@D30mZ!@sm66|`=iQ0^(kDyL)KF@lZ*YktoR)K{ zJb*`rzVysmD`QZ6no$DVr#TSgD(t`w_^D?dj6q0Y(#S75G&}ezkiq0}Y)nma>o7#W zrmVa?{?SzhxoE%(S8rJnf9_vDNdiZoqaOeU0h*#$Qo$(ExUZC`Es}lDm zQuGYG{|h&92ZH}Gz`xd3XKHTR@9*wEe*72?%oq0)u?t#&nNa)w)vqC%jnfhm!iHzF z@%=>{O{1wM?F}V8lM<_v2@vW$AvNYp8~t#x5nmQnZa$%bx#GpuP>CD57cWYqRHLe_ zr(Px^K7&KhBD(NK0Xhi7UXMYQxPXL2R@G8DkF`rg8A#EyH7NlrAIUcDj$zyG4jll( z`aT22)=2(bB%f9!WU^)MOO}%S9qN~PT1RTP)Y_TKYp!eS4uF#0B+?^}{4omJx5Tw1 zC)FA0Qx&}4x9n;KLVhQ#$Ii#CCr3k3v9ZU!T(83u{8ew9GFT(P1_tZc5?4ec+JXLeE%zAB zlZ@kWu>p$KA9o4`GkrrD`eP1H?R^r)4j*|zU&1I?g#sw{zvVj zM6x`%#+?R+MjP<9Tl1TPnc^7%;a|}+`ehtk8Wn|NX9MKZZO#&x`pIZ$+uYZc(^-O7(zYmJj3bX!af(=*Jo5cLII9n#}h#! zK0((sjl(ZgvPaIZm zJnwF}?!MNLzdTBBKYT8BGGOvKcqJH_z4osCHl@|?h@>wO*g;i*z*EZKk*`$xA%s*vOy1}XywjBK_H=X7Irr6p6fd_nsfiI=`bA=I!v@3%)4q zNHnYA{e&v1Qp)Q}BMy}?C-r=Q1C+v*4sd~HThd~ca4aXL7DvL;hb;3R$FK1}uY?;e zsd3tEt#9l1TuzrDA4qWKTW%7cy+71&mX!Y2Z|uFr%qb{9)5E}UX?dNTl6-OJp0x_R zu8Gr}TieyT4h8605#K{_`@T8f#UL6=SA(4%#OAf?-GQRElAZ)QAmHGd?012NbPULYZsGgbL-}yc! zAb2It^8g2AWAu$`-v3Koo$Ha9`FVLJUpnVt-a&{Ix?Df=#dw97BE$%JQZixC9 zr_<LH`zy60wO{s4bWFgwe*EXE8V9oZx#f+pUnBtE-9t>Xh7EG_Yp=jLo zvmgCqm-d9qj(2}5DdC!YQ+K@k^X%@*9)Q6I!ElMLw!l!dfh*taCUC1@;1RhjdmY%8 zyND5GI$cd0L7(NZ`iKB%NJ=zVQlXv+shOfP!ZitThl;Cwxl6nBg&&Z^s%g>8Xh5>$ zCo}iG-f06Soa#A~qIyVZ$gOPpK}`<&bi+N`(}aX|Pt~-7$C}QCFyUIwfi$!IyFfmD z44dp(*x(iATyfEKlQVfYL%s!Mro~!N(A@qNAD>F9xs2ZNR(@=?`@T_G9f0d6C@Ex= zer@$Iz7xB{oGW5(ayn%lq$aJ=>L#RJ&4mzJG@j{~ak)LQ*tHH>sp^9}OBSUsYKb6-NIS z^a4a2B*kt&ttAp!=SODv=pjy!%NDB~Ee|Z)IAZ*2u*eZW(cG-trG-k7BXUxx8**0q zLe^-eA!oEaD+vb3Hzk`sws4EJqBw~PD=N=W2kW>aC{r{~$rqq)+og}VA+Kt%(@-hAW6ohDKy{!cZ9BMslc=2c&Q zr%|<>zj`I2nq|JFFtLC7KpuR7#~nbcqz>>Pl^2(C8drESCXXSVAFemMw?_E{G^b6TrZ-E42kJTGPdo?hAUkIme-SSpJGuY z2D#7r2cP)Y5bLu?%1(mH4W7?~V2vXu=Ohn@3K0DhG zI+IV5)H2fexOKmjL@KBDh`!MYmekc>|2QgxSr3d~NS8buzi4{@_`v}Rd`{O3cF$}M1 zYlH2K(?ji^m?(KI5R|@nQC3z~U0tu#Fqc1ps%mRfZJ0Xc-4`kg> z_*45-zFLL9#WiiE(2Dsh2v32dRH?T7&oHmFPi1d}xG*yhCf>`g=nrNf(&Jbb2c$Lo zUK^2EwOT5GDK+`eKS#u~9`-4ULSvIyWy2-Mp~mHbRXhZJV_t1p%f zkQlA^Ij+l=YvMeR%`#DGN{yq`n$zhrFC&v(nUXsoovA*!%(shdTEZTAa4Y(aI0$jq z$75GBQo;T3)GSh-=28scf{{BLL&HYxgVO`tapk^0u7T(py4cD885Q6JP+>sB%H3Wo zRh(T_-P$ud$bM^-lC)uJX1}=nr&k#ew7^+vBo6^KqAXiYBv73aa)V#2V7;{aflBIu zf?0)eKZSJ741EN>SEfLdqpr0eoJKeDcN)OIlgP_Bs?->n``Bb`m#{I{+X6s8Pv~O~ zKd?kN(hS|TX>a@Fv7UjRF-4fDfYEXi3DEft!dGL^7OpJ*vlg)s2S~C$LN~Kt>Z2F} z2uc+dRkiiSY5Euw%`(BcF7e^&`93RpLJAZ`*(OnB-iPZLs>I2MPc>n2>K~N%SAQnX z^2t;qwA&-w=VJNq%pDY%1T$w1P4P<#WLSgM31!DN=Zgim4)fmQs`chv4CYoK?1T)w zh$0AOs>o|$daJDEvtN`42TPo!UA~gnVl6T2B!>va+!DPfhNw$C)z=CZMCyynV4{~m zB?Srt2345$Pbn<$9o7$sLa^>af-fH$`5nrh?JX*!q+3@2DR25B{r%lO2ssd$Cn9*! zt`;hd8{S^C79AXQ%scixNg*I-&a$SydGN|B)UM%edp3`tdt@Xah28FGnISg;9((mH zqr&3~p%bkgU%M!&C`)2FUMp84ED1>_mM5}=$mJWcgg@OmZI1m~jYVbYP+8v=!-mhm z&@H1>HEX9q@(`RnhC1JJ^-c_?dEo%_jMGp4OY(bqXQdeVMpqv!kgAc4S=9sD%m)jH zZ@&&5_aqL5&-Uiv0|z+36%a)ZKlc~)c(c;rM6KS2>Qho27k;moK_`ZcNfc9Rn$X2; zyx_(JKcezO3>qf!kix6ki^^X+s=IyU^Uv1F{-ehB6b1H9tTQWHYkTI*VdECRXX?yp zPUW1P`z+Sz-{OW}RWb-CE@hDrhnjfUWEguM4fz?dDf*VCCn^BG7o7*{RJIEp@9Z>i zjCWe_4&`iyue0yHg`sU+`OZTEb%?DNGY`AgSmqf2qp|k;HXq6PzWEY#P!~8}$jrha zEH{p*+@N)MvUG}Vh`y&1bI%sk#@{w|%A=}IAIu2%QYc{^{K}_TTCd>`f7sgj%`v2G zY7KE}ogscnwx8h{>i*Io7uu|X*sWgNu0(8qGZj|C$rH*Qv*50>eV#Af4G{b4_5u_% z*#(Oh@2&Ydys&5G@;A(-w1R%ZoRu#3Fw94a4(1wH*7F~enu0yleEUZd@Xz_IA?;O6 zIdi*C-fqdgm%_89)@Aimx`u|PrmoTHH4RN3m#@@uvb?vMu&}W$C#@Jq$TSiXRP5$p zhuzmR?#r}+(hQGdqTZKIvZ(|(5R{NADMs-N>F0gMgpKc>D2xXQ#XMMw_#-NesYrSb zU_X-ix`*Ua|IC0s#EwGMe%Z?VSu00LFAD0gTHN=TOD5Tl#NEqhFGfop(YkC)K4?$& z06vGmOyJG%=PI5jY*H>A@?W?p^i{xwENsAgx2Crbb#=M@Q_tG&-Dd09wxG)kr$Pvqw84Vb0eGj$NZzJG(G?i9lg- z@jl=4CHU}(YCNMHyDX@eu`WnYPrCn+BWTQ~?#ER6j~%&GS3f?q6}Wy8_o8cBbdzI? zr-}WG)tK3ndorW%cH&%&>bSLMYZxtNZtmts^bT|AM?>J-Iua_yU(oZRSf z%AUeyT$FwqUdOB*QM}`-7szR5=2q>$Zv=2G$c{J$5Og0iv+P~XWZu#~L$Hi|yb$Cm z)1Ip9j9%HP;Ez03Tx58Me8ghfWm6}7@PF2wy^o+o+0H+I-X@cimk8?DVquNyX^`1u zwfhzw%O9NWM`CdIY0{wxWz(upAXPZo?bz;8^B6Q_ZLTvqh8zqG3^*p173JD;?^Zrw z?-{Pv?nQUlyh%p(sHr5Af0lg%9sBHR8a!7cXz4CG-|U$%W$YDKob4SmgA&|MVR8hi zDH8*r7aMqu`;Iq#{c_K!K}BO$JObjsmbWY>$E~aC=ZA3xWC41t%+%BJK}M{8xQk4( zX+8 zq2Dvo^7w@Y2DXIQ1FAU`Yx6jUey&x$dK)+r7bdx!zY1`a?!O-R!g>GKuPc&R#xv5x zORe&&zOx_rNV{B#9_~pC_5=(D;Vhao)~JzAhY80iY4?eD$tR$FegEiolu)a;&?>Ne z3N@gRK>kn`9P%$DPkG0FC+9G{wYRLybF}TCSgkRY^LYc~Yz~JI>h9sOwpaEJ^c7lcNbfLMZ6Hu6}iW zvrHB#qvhc8=(h?Nr4=eyA_{Y;XYmoFOaI{yQrZ(TI-PK>r7!fOT4hf!p4s7%c!rGf z6tX$^2J+NLxQ){?Dyo}!Azv~#*sm!VL}GEL9$`2=su+mU@|RzJKBS>%HAN>^?wFk7Amz7 z%fRxK<&z@}Ax!{fyPX%J+|UX14A+rb7y0cNYG(V?K9G|w5SQVmIjCaVw@hPxLeXww30cZ;Vf%J~iRP95VsfEXP)|l2? zf4~B7&*8_2bSV6mK6gH4`JB_r{rM$M-WG$DlK&yz=f6CGP{gQGhzV6=@vkBDToOPb z@wnSA_Pm@-@z~y&0_*9?$ntof@2&yVf|-p?RA<1O`giYmMFhfQ_|$RA0M#=)kF^T+ zQ7M#%$t@ove+NdWbm`4M8TN%{>|`_DGXD*Dy{rP_baY|~=vm(vdAb9nPU%PX_ zc3&SnO;41~7DF)vo$MNRedJ(e8dYMDST2ioCeT<@#}}{_argvbkl4p08aR$NVS|@&K?{KOf^# zOdH>I@p%q8V-|Pclq3~VU-zY{py&B*y02*MQxJK)+Mfk-304u+umbyyI>e_TVw9wi{I(Kc)%((}K_g2frPw1^ z_~52DYHi_n6~e({7YBEzWS9cP_ZeI)-RDb;Z#A$&6Q%YdYkIdX>ZT8LB!t%GA;C{ac?$11bo z9&wnMnx@)SC`$}EAc$Dl!buYQDyyrzmY30lvhy=euY2ke^+vK&3N(8ZSI>ti?L7+k zywCQ{uZJJE&!U{RZ#-2qeIlLB;fHJFM$4xO#U4k8e>J;ySa>K6EoF9(h%Oim^p2A4 zb2Gyh(SXFA|F$Mi3|=y6MT0_e9{gI_L+AVNtPl$U8`vviSRg&maAfDMQPSJPDe=#9?rXv=C*=UQ>U zUSWlVL@`u?Yl{KYDLNp4%=n^hqs<>R7#PU3l&Np6AYG=IT zs93;aP*+J{T-6KsMpL1Vfg4Gr1T?~3fHl~&J(dvg&JN>|k&^)`tl8(!QQN7{#`#JX zO~OlcDynN+gV^w|&-Vd!Jsz=4XvukdKjXbm+X6ctK6XDEX}ES%-3l8Wh#UBTme511 zp2#s5oxs(%J6e_cNNGczr7HuGodtx2hyn^k}H2BUIvnPhl8n;JbEGb6p==zt`4 z&e#H)$iiOR_Ii!KPw{iwhvOkpW8V>%T5%S9qvuBR-h1xt=ib@po|U$tsHt+ty_<)) z!RV?M&A+FAqsOa=CB2z&5$pftXBX4i`CxG4)kyT)-@g%YgJuU}ahE0AB3Z~45rQ=4 zO%+=pH?_aSmFG-1k=ib+C3$c>h>$bUcv>a% z6;RWI)x+yQ_$8>x84PgNB09FJdv_J$4*e?PQ{+~yoXkzDMOsWAZm~|kD_fG%>K8_{ z4|4?FfKO}6_|lpHurdBQd2G9@?6H!NU65aso>e%cSUmCF>>2!+Z5YlF`V;FdxuMLI zt0ejy*~_}i8@_9TKluhF?+vxy7HWRF7$l`*nRHFA(Cyreer{=HSJYPZXyMBX;7G_` zT(<%-MRTW5Rfml@d~mXK%W!dMBjCmG`thIXwggT3&h0x51E`49tE9a0Ts4rHCqWvK zIpF^5mVd%4#66Jpx@CK7uahIm^L!x?ICd0O@=I|zLJ{qEme3n_xOy_z?#GeYQ`YLP zRNmXxntQZk=ZD`uF5O`a!$zu*o$?kos1GMQgehE^$Q=L(OZZa*3s+i_TWZdhnMuXR z-!MKp9YhrQQJ<{$6OruXfzK1!_%VL`E}{rpocH*dE?T79Kdq`KCpq-nzD5E^EY>d^ zL;NmG0QYZqFkoE=dV&&bE4p;WHP4qZws@!E<)IA3^;GpdP^d8JsW*>?;b6+T>?aymRWZFO)9r~Tlv zjBCHYB+s1md7>FVU-Z`y!e;$mydF3>)7MFQP{{J+i)4 zks|R7XqteY0-K`om87E|!IzyYFY4*WIBe=^ISuO7(K3W) zS)`DzrAxpl*fEkCW=nWwUjN)qLrk2KSRSe$CU5yz(3~=UC z^8Md1jD`A?hz~U*F1y6ApHO}F@Caj}@&DR<#T;KkGNF-hk}1Mj&1L$?IQfUF`GG<9 z_O@kArjTL@H+*nW>-W?ok1+=z`g9d4lW%Wr!}LlK%Bd<`<|HbWoi57a;NkSjJ&Pm44Wpmtvp0m z>`kG8jG9ctK>FHM)f`e?+5;?J76L3;x0_tkN(99A5 zSo(DlHHoltyIKdB`h+H^U-nWsib2eHSnaYc7AZ75viXdvsjsI8Go`|y)78*ts?XKX z4(LoL1&xr!_RwDteZfaxWL~LSwhheiny03xvyeqrInKGUPfQp*r(BP2SX^J-7+Uu3 zd8)_H?|Lf#ZADi1XG#i$~VbarO=0FPDg4>4L&;C)~hUq>mmhi7p&+BI%t~wstYG zhhF0E`~={O(AX-Q4XZwR`9`M=Tp*-g3Gp$CbY;n3$1{DNc!tGgXlC^(e%1hgNV}}( z*w$qsN0Ytke)$1Fu=bQ=(~tz`(wn4jzJ_9T`N+6b1;{cmE5;w%M7Fg(1x!i_lcm~6 zC%kaN*lw1FCIjkyessVPOJ9Op zo%czUtU6Df=f#Raoe--AA3iu4pqsmdWwgkC2Dq?G6Jlga6Hw_?5AEDsvpr0 zV~JlkFSDj?(Z|w zH#%0jhhgw4uU$&Q5QghT_5*@PcIyY%g$!S6bX zjXeTvful#B;^eT5)r((Gr;C0SjigUs9~ixwVejjcn{juLxGlaC_N$JKIU`7Rar??h z!c)zWYt2q8N24+q!fnSC2Yb(!@`mhtm3D=Nh4u0nc6U2Z z@!Vt%u)9w;;dPI)B`al!O!k+wiL0KTPqdV!MC-ffu;Rw=ugwYsd&VL*0pV&6hM`}- zqRU*-ekcN+7dJDiMH*VEb+8Mg4CT9CX3ff1ls=p1-*qoU_?$txqjc8Tt2^d6XI-Oor;TF8^DNBTC*Lx3DOyN*7+34wqs>OSq+SdXhp}k1l^dj;B|ypX@?7w)uc1|<}KM$sh2ILsz*K0%6wH_@=R8+R47ep$^(>9kD0l{ z+AQgb7MWEg!^9*cRHc-~n=MyWhNFjZ*@6wHgDj7@p_8bh@zBOC;nm1NWC{UDserNd^T8Uc@M z3@iy|?cUQDC+^SfmwfW^oj2hQ`?w(R4-{V6=vI2;M71sb9Nz4gYoUB@^Vjz$h zY@Q@xr=G|AGa~Src%+#=aKF>MG~*)R$g#Xl4z*lRh#t8(Q4_mdX1JTm_s{fN6YV+4 z6+YNEh)x~k$R0NbnRV@3cPe^x&dX`ZNV*Z)=fIrdp{UNtPUmliT z`GLU=RTOOb2hy4rRVI{l6bUuHb8LBEZUn!8Zz zv|CD_7kH8aDDfhUjN#8^V(q`eFSl{_MdA7b3Zkgr31VvW*|K1eQGZEEeHa6Ue~u%j zsGMy;_--G4Rh*HzooiOh!xz8=+8vKXNiEJRDU|og&mlJI18&9+j#^3AwLR@J89D8T zw4JDa3iIh%^7)21kfgFXtzP*^%@zYuGvCPZ6^K(>UejW`qo|}gEkXPq)OsT#Q_9?b zS6}htz_>U2b9--G4X09=576WzlSQ1LyNoDh0-u_7L`s$^Fopv%OW8>e1}^S+}pj)TAPF8iCv=E8?|Vr|g6kOZo?=B+abSu)1-a zXb?(-twBLqUCcwc9J(~EI5#}PRh5yVvNCs(xp}IxEV2;@MP#jCp=Z9<7MEO9xja?L zJD&CrHEdAm-k0wX6=P}g(KrmFtV~lj@vjht9$Zd(2KtO9A9#c0g`b`ny!9R7Zg5&{{vg>WEen+TK_p z6W4+R{*GCac7Fl~Kff}4O79PyGkDBl9%6FxUKg^>C{TlA(cm}8;!1vhn2A57^c-P( z11sU2OOj<~IG8Wb|HOw&*I*R@vsVS(Gn&n!)}H>ZnT~(OOfFY42LqMfCvCrKh7u|j@b*Did9C?p2`on4hu9~ue%rADyuEBx>Z>RgM+=@ zQ_c525>nF`M&qy`!>kYA%PV`U@V?_IGn%gEIqkc9cqCO2l!DYU`pb_~lQ(5AWn8pBi`U-P_Ec&*R5G3;3*$`01W*3fJMK*$gG!{8 zHDR4^HVKJB&sNvZSQu&kNID#lS);HA4o=k`4h*C)JieyUT8)q*Eb+^5Z zw6IZ7`duRFlJU@FMb;1vU>%Mp*86WonMWgHt%8Y*7+y@&0pJCh^e8QU!%uW>&WSi&I=)E9Ae zU0wY6BO0bIA|*XQO-x6j&O-4;_DHQKciFSke~rmY=l`IKU&tXa;~t!5Z^|uj)-E%$ zvx}hRnSsyMuY{%arQWw^E-%BckNNjqgn`*rmcu`dF)gSw4fQYA*xg#+#h8*662ql|l;8xz)PZS3}_vP^?=2P2n-;6_|gTD3ZFL-9r?JghG30Oj^pD_hyaQ)-n@;WhwM^Z0A& zq?r{ch+tb^&N{k#dQML*4%t_~guY(ozp!6$bNjtC21XdEjutW{ZOu1T)e%V}0)3^8 z+|z}NJkr$-f6-eT08HzV$E-2XU`!jb$qJ{i>J&`wiLO5aJV}r3dkHW5n9c5hpAmXT zlYc*BQc~B7G&sTWj;`h)36w~OcW+(d)R>f55_S^wO9N>WzNIP!`BDyF79X+v$ND{N zU7eeL8tR}Ej*UG5X+^zT9xIBF;8BN>u`50^R8|qlmQM?-c2A zQe$M>Bu0vdYJU+ivQtOfAtzc8cSlmcGZko~F(;z=zUnEn!OEpTj@|pohA2GvD2gqz z(5?r^#obsQ47$n){_(x3ingUsGRQXiSi2i55UfJ);*f3BfC`s?@PwXRsKtoa>~l$= zt1Aexx6{Pqbx&-|p1<#|am?0dd6V2zc}_|u4EPqI_w+F8fls!1ck|l6ynbmj6KH^d zYO5K?$V|QYLKCr~{vI1=S%0MCM=CL8^B_O;0U!E2rCiKKocD0oKmU7A^2#DQ^T2l7 zS)6IOE0Y&FF6`tv_vcSa{JP_0mW>CBl<5?N;KY5B8lqqjr>LM}jgg!oqnIxKINDlZ zt%8gm9^$yMw>tC|00zJQ75ejMW^#F|E3MO1Emu(5T$+~OX|=edGL6@M4#3dQjM5jL z(D%lSC1}=zS+flqtyqD&1VDeuF@)o8*M}T#_Xg$9cjIKez&YXAzSwg|#8zt|IT^}d?b$RlM$lD88wx<6<2Swq| zw10m7ppnGFis>J;ssln(2ql2bte5rMz*2Byr#+mHHa@9K_jA$C#;VvRse)JaKF9QBI=yP&a+*~3(``6fH{Z=!jaTXO2 z7Z%*{OU>@%X1r9g?A1rr>S9yR%F(Tn>(vW`Uew(#29I5<&LByjQz_g4<0 zI4sd*kJh?9dQyD3Lcu8qSv7Z!)@TBiB$$0xYK7yc3Yw~}rUh~Tt&33v)fp%H*M|q8 zH*6-RuCAzw-#W;Kcp6%Kmwc06qD}OyT!|`UKiY+dQG0`OrD+yZJa*PM9a+Kvo*)l z3Z+o~9D6;!llyrWxOU4KOH^uUmPsF`g~D_;Xi*Cj!*Fj^5_@$2Jvsy(gafp-EYYO} zcFfI-U(Q5D#${*B@vN=ApUbM<4t2yyXRFJKtcev+lUW)fqrAxkM;LT<(=3=}b%j*d zTe~d5Fx`>C2;BD~y|s#5nSc@r;wCtCfR}gbX6c-WM9(m2Q8CGbv3A?cCo%va7)&}t zKR!EA=c;k%0)-)*qP8%Uo&qNtqRBX-ojY9PGHq3rkl^-dO$>Vf_cJFyzr3_GE$Q56 z5C!*7M^af`ne#6R*)puh0~DfPGWc(PcP}rK`FfsgW4`Ps92hZkA!3Y5z&TWeWGS&j zJ+ZNG(dI6{r@rgiaxvj+-)_=sGpB2AxeTSDDy~R? z!+agF5H_8M+KpjW(Yoq|S;8$*jP;0`zr-=K4po8}|W>w5}pT zM;E{92$?Bx{yY_5vqQ%Q)`kR4?7y?@!Q0D9J(*9V4IN_GEZ zrUr)15flGP1tP`G&C4gH1kTLPCzIu8Hnn4geJw08^ub+JBpfkH|{E zkfcDxMAESJjf4|q&{@lpykK|bjczcLnVDNuUYYw>*wY0NCA_5+Q&Qi1=dgB3)x2m3 z+!X>Yn+T7X^a z5plxPT5<4;Cy>NwYQI;vU&1jv7h}rZ^Oa0Jg#;56_iH_p1?XwLkK z0h|gXA*Y3RCTcV;J?rjg;{F?cjUi8AJ)E55n!krvr1qqN3UP1kU8~ za1O9)hcM*(C6fz#7LlTuzLXGmx$x!bw~6Vh?)lSK-ulHcL!{PyZCav#49qtuvZQS) z2i}zN@HHk@3~`Byb_0rl%F0TSm-#Ioo<^;5fuImd1pRpBg>Q<74vy(S(G6`xIl<}5?QCGa|Ym}{nrZam#z@;^E|Ol}9bVKDnlvq9@l9EL#>7XCsz z$r+s7?#TyudYI>I0FoKm zRI?U6c0$Y#aYdR$3C&;5@$>jo+Y$pQbZhdHJf?qi*dl7>Y|nqn0A?Dm*c*IGL6Pwy z4smsn%tDfQ`26a}f9~w`;6_g;3Ux)qSb1Ty1 zs%fXGaSCz{UT>Ig4k7?Q{pl9q8V&2>y;(YsuMnbivPPF0QdH=_kIj7gFuQ4Fqv}X5 z+~8==mtR)WjA)?60Wf*MRLt2T)H>hhg3HZ4eGJ619A+5;?FGFuLb95%KW&2exxn?c z2Vgau^n&C!RcV>5bg@ZzJ3<2;%8l z`grm0xB@eCGiSip;dC~a`%PIpyF>lSrQw$AqxoO9Xi*l?S_MIr$d}ZLEw^x2PC%gM zsd2v?f6tfgdkRNop@n*L27agI^^O;KmeYd*XhCp`QN2b9qpQFY$?ry5r=r!$fl!+_ z|IuV7c)`vtJh4p!n`i!>;unm+E9L;2d8D!Z+41B3U;;4_#dfB3p5;zfy#lO7tuBIO zkO31KZEUZ$Gm@@u7_%Ih13lMBHQvaBHyR=V13fMLj>_9i_LrRe*RNmUjji)wg6Kk&cE$;gZJ2tbqGyyGEX(#C`$QXiXXn zBFWDB{@Jb&(n11sc%uN9lsKq2IWwcGGN)Lk&FD44ZOLtLcz8se`kXdwsaLrYbo8j- z(0ez}_!)YsMr2Z&Ui)-f$4WiG(uXc z9k76WudcRUpTY+Qt^MO;2|WvDe4rHsDBJN5k^aaW=;R>N!tLg_z!y&yE1fYq{xfh5 z$n6>vPK}nGt@_ye`Vg*VV*FLH@)cv;+Gt5~>gQLSj3qCM1;AM9C!K%JL7tQZ0B@nwVALroDmY?=; z7)IYIp}4H8+qSd2Ki(6IaOw$zcV0I);LAHQ11k+gcQyQN)o*lymxhNoYH^LSpy_P6 zCIwniI0@_b{H^p1lODN!ee{0fpA>zO@*lR*yrJqI9=w?<1WPUk&0knWS434*mN);D ziz$`h80Q-QBjA?iBOwO@4PnItMA6|8fH$~xn-}uuFk|~e9f^i?p-(dg#5Xm$-gA9! zJE#Br`;yQ1MoiA!pS8hWn(8fM(XD4st_=5oiiLIr7MT(S*Pzmat}EIg$e~@pUf`4e zmoHy{RHfH&a|ZRZ%Flr*@muoxt#%lsd`_h`CAv*V1Tp#ztWNA$3$C!R;ifbU zZQ~#+;eDl6Wc__^qUhb% zZAxF%rJ6x2u3{})k-5HF7NA<5l@kVpN!3W0yK$$vM!5@h1OKSs%Vm4-{61sYy^p4i zJqe%>;^E_)TwV^bT-Yw7AJpCRez{lQycf&VL2WhL^fryRTW41SvL{i*g$wE(QCL|W z5uoh5j=UJEy5}O3yl-_TZ9Q3VLBy)uiRaB8ZaFV?)`G6bj74+ulNh?p3t1C5jbk~#@a~`0&B@Sy^RlMl~TT3CWrBnQKi}jt>omU5@1nOu?%nqsoj!UdTB}~5s($@D*Tl=&86KCte|#c2 zqr);xgDjz|3)kT$>L;jAhS@|pP|M=#g8?s#z4Ap@_u$Y#$$E~9{`0DYrf%|q%6Gr- zk$$68RCy|4N8vF?^Nh8G6yKt5wS=-|XLvcoKV@S5w87hMW;>U`S&7tiHFj8%)y0Fu ziqOc50KKzt6V$6VQMXpd4AQ`++CYNMbO3vc#P9iJltx*i&=zL3eDPaj$Q=zi)n-Zq z>Jlhf5&X+bBX`(zi4Opc0E|W&F%qDyGk&{^5;E~vwwUa<#GgLSgXv~j;F5gXT(|-0 zKtc5@diC?Z&Na_GKBirhnR+c7%*HR56_BA7{#+AX)SN zub4GI8q*t10^?qvfQXn4=~LI2F4-{?XpcGOX-R!$?x7KeOLW_17;itR{*bCB>%2FBC0K6ALRrG=uYC#b&L}37Neg%;~h* z!!^Z~7(o_7F{SqNVA*p0Z(5wdiOy(H)pkQ8Ur|0ML#opvaAAdfWf^v7H&$ZFD>h;V z#uDdlhbbAZ!H2kP$>afbb)2TR)3}WjTP_fY+n<@aB4*~iqfglcH9AU7eh;t>wls=Z zF}(-IzX^=zGV*hQIvr!$6G{B0wh&7_Qn1l4Abc>B*h1G-_Y~EYx4y~rocK-*`isMa zj<5MHaZIP6e>2vYd~>7&@rF{Ur#B|Oe4ektHhI)Sp>OlgA6{gB<2CuT0toY0%d8%= zs7KGgJ!UQ-1F0Kcm8AkR1N6MZt)30(F3x#OsYW1KL)C(qxr;2CVOQe+X#s{jj78QM zG8HDKmQ{Sc_(}O3Kosg&>$J*Ts5EQ?m~g2!YR5(LSf6~^tV%{EQy9*W^;cU%R6O2_ zr?#Oneg9?C;L*MZD>~j?8wOvEz=&+^uvDu6(z2+is9}leTK=Koq|kLIKf`n8AMNIb z@KYcHIN@SL9uBB(Ze1b@ni{$ob1odJxZNCyc!>SA-&2)Rhb@x=NeI3r7e=y7c9=Uk z5r`vCppz#ufrrifs4{yzLJg82D7Mw!ezgM^SNiE1{xF83f)R&=Z4DRycr$!)#^IW0{C@tAr9d^4ae^ z1^^AW^uduqE%GV#k%0>`02&57CU9E7XiuoYmaagry`QWG(-beeE&wn-QLb9DJ_@4tXDTx#SNuk3;M662MEFQWSLfBN(L4QI7&x6s`ANn z$Q?B*s8umXKBg*4`wz^+c)Pn)JhhWL_|rc^`v`+GSg+s{KLvQc!EzN}yHqGm#N-T3Mk={ z>nAd~^OQCp*}yxR?z^&nv85q}9NdC6P35!h@CHdtsY>fU|1@FON!Vj~2YU|_SbxcL ze|)T`cPI6X?AJzA|^NFVv?ZSL{L1IkifVo1}07aPJn88&`SC=kHDM_*Hdu5fC#TlyTyEzTx+#;d$BIfk&4;(`OHM$_hLLwHePeIv|>!=}jmv(=FSL{NQcncQ-10u#51R-cJ6Z9??lrusEKDl9+ev}f#Ue_lm zw}4xT+-PM>Mu2X8%EV_bp{XtW_MI6*7AjbJVK$k7Q2TTVstDkSF5SGRPymQ~whJA6 zL^@z{&6>#(@yXffq`u&u{^jLalL3(IjkG6J|EHgQ!l6?B)_c_(q71eG8T8Hlat;`m z*Va9>x1WEW_~?1O*sE^x%EbP97V(egN{7DUJeR2h!$vo_67#2p;`=5PG>%w-=+Z)k zf5%9cfLnej7~_#vQKZeaI$OaWYbvf-Z<|N7xJDphxYvOp-qMf&Zr29uj?u zgpiE<^*t{}2n>7E?*cw__;{>2z>bWBlzw1=~hoZRFNcj81tBc(bH5 z;@t~?X7#D){ZC-#g~{f3+|48uQ>`imXBoYvOT&wA3Mwr}fF?NpvREOfOt8F4a4T^V@2Sx)@d5r3S(neUzUpXtLOEOwsHW zN{r|ye#vI~(ixbtUB8KO+VaJ8?%Lc4XAV|ULxzAHX2U(&Bp#f{~D4qZ8Fan$4(f0EkzxwQ(?;$*N~DX$S$+DJ#%VXQb6;BwdKYnK*FlIB!ua<1}oo ze?`uccle1Xi!E!zIC$wtNlSp#V}2F_Bcd)Mz!ZC*SiBUUwGpnN=?*8;_;>6sDU2u+ zF+^C%5m40Ld39Y$f@Ed5=HqE|Ou7xqs91RD6wL}gZ$*UVkgb;O$40A`V#iEQFNEQ| zSztG*2?2&?+!%)Le8Plx1TmUy1OSBFGgHw`CLR!LPdn#AmVJ0=M*?Oyw{garYXBf} zgXF}n$1`#yP*g#IDLn&#&^_>E^MBsp&cElSn1_=0yJ+H}%;7s_Fyo|YX=aoQR55n! zaPaGDyBH_g+X;$syUD(V0)d+^gX$TXO|t$~(bjps@i!+Vl(NhlBcj15+AN4Eqc0|$^ZG=e+T#@_;eqQ&%?(Xb@HWG z2E~Msf5gRuT)v6&ovVJ&a-g7f&u?mKPI2M>{Q*Yk-t^*Bh?7lIys|`x)GsVAyqwz) z@l5ZS17KPx0IgYWR}^2KgdVR;Zm82R?0S<^Q{NK{nthiq)S9UAl%Z`_>)|iu&_MjZYTNYgKqb7ifsTiVcY1NLD|$z{nNzIq*5m~nUi!V@ zq*wIGiPLQLhvBIc3Sj0P)X^NHMG})AW>~f z{ak_6x0KY;mw=d~N+<#X$!YaY+FV`^JdMCVA5Z-b^G~T0c?T21@oCli@nq%4%FiU2 zD0Purp}_0txCm&5Vu}}eEjgys730#ru1kb`c z2Sz8c<*MEm4d6(3OCJmW%m>u|8;Gzd(hMmoH36f{dG~kPB3JX~zdWu(arkrl^PY&* z^96f5{ZG#}Z=vHe_Ov=9T(vCd*>H+)Y1u3QNYQ1DL}(m}s9d=D_FGvxW_h4;PT z8SRkn;&ODCF5@wg0(z=J5P)?pH*pS}dtqL5zYpk%`+)njO4vR?OX-`XBBUyk+VM~& zO+$}5u2im~((cP(Q}clgp$YO%#cU+nc_@w7U6n3<_`IV1-X~zEuDx?&N7?UQy}f5G z;Q8n(S8Vk3wewZxG|QtYUfNMw)ODSjx@96@pNeJJRmbmzn+n;_>cZ#3t*&P)O18O# zWmw_K>?0++j^Z6O!BUUo9c+M&L&-BuO9-|?vViv#fO~?0aQiMdayY+`jtG;9daUzF zDrO1Vf8xQDXaL8>z*ur&OpgX>|2yoBntTOCVX}a&Ig} zfzDuYMfEY+6Cg|Xj}Pf{$G-LADBu8W$6nKXJnL@pNsbTdsV_C(E@d>P{(eC8LRo%Y z$5Ued?+>P=2wje@E~}IHh+qnwXcHjwL=161G&0TO(<1&)gE zguVXmnkR^>Sz9ADKgi)6;6Z4N1XPFRX595Y&r6Nhex&%~%?^l8Z|^q}0!Jp!bjkW9 z!T3)dUpx9IJOHhn3mIVa9xDlk{pf$K3;3wVQq;wj<-IUxW^}QFY)6Zlm}?>0Y`S-S zbM1Y%&_~gmHqCF1Do9cDZ5{sgAN7WiN9h}1l*a5-P`B)Dp;4R?dvdG;`PhT zVE~l3TdyYU!#La;;Urx&1gOhdr5p1NiR-KH(Q;broXJ_pkQF1_lz5Zk|M{A_av zzu3Vj#f!Q+ygjSI@m;`^HF&%%lIfmoywo_^YRCJ#V)kd7H510@C=c&!%5Z5C$W&?D zu3^HNz_RxG zqD&^>9yvLvDE7Fp_UW>Pw`U85?7ay4E%zM9W_~zmuvps`kXqq?u#jeJ1Ky;3@@f9U z1X2N`R4F+^=Vtw`&#GCQVo#uNPZKnPT&}BUlLo3deYO9Manm{y^}mTSvURhWEg6r4 zUpS)b$R=8fg}xAGS4lRRiMp}E-mbuY!PRKoa&s00pAM`(SQiUNdebE28n8@WYo8gj2 zuj8w}Zx%dqty{(oeg8UZ?FGFdS&1W42tiOxgpuTkG)rcTLe(QuYyjl6f1P$Y}S zDSy`CCAG;r5qr$}%|F`;J@sANpfmEh-(fN28F+}9b)DI@*KhXB#mR_wgxBtbOrCe=?uOf+UhmppuGE{aAfs$ueHm?k7kssIb$19 zn|-8C+gYS*y=MbNLznxEvQA>ItJHi6hR%xbe2$y~$bv78J{^LjIB5Cg)d<{7*5 zA6UiiIx%aWS6lD1+wV#97U~jsoNyHs!Is_v45p44d3ZTO{#k*~4|6_e8xc)AyIytH zrymJ0(9iN;rUSPx-c|QpiabED|LVb;`ZMb`!cvXno@ybV83{XqOT+=UCcDN576UMA z=oFIAwGOIcRw+^LrjJIPpP#|bS1)LOZAdHBl`!xg5IDA{3G4szM)~S5%81aC`^i5H z6*cL6SjJwJ=;7+>#(5vuVKT0kX!lcUM-`R*RKvR{+|)KJxs)l*4j-0{Tid>tg?5Bn zn3D}je=iqTs)>lk9-V6(%ky%dSaOw_vT-SO$P&O~6>$hpQ?2doDmmqfE@IV8d_qkX zz*bebQpmL+$uL+KAmu8VgL%V;qEZjno~7&3rqR4mYnyM#)y2WZC(o29(N;C9SVl8) zjAzlX(3RK`-KC-)Yr*1|oX?c5=hq<5im+nh1mL@A z)WCH$bzv-a&MZT7E9|R>STV)PeQla?Z4RCNx1pq;(-xcr;{5BGy3F+N@|0{XAQ4LB72#{JL!=@<_uVEU=#PM42jep7wl+xRtj2G`;uJlMy z=Z5b}B(~urO;yI$Y!1bXZd#E-PSDaR6w%pTXO<08C!-(V1*K9v!vma-195A<4;a{Q0JmmsXNMy`J}#2ae`r{l+I886_})?+8OuO! z{ZT=}hk|}u&3V+?DtuB(xCN1!mynRIq*Y#F{3|0(=6L-To+4RF9%1kH-hI9#5l*8a zQRVs9L>3p_=bzilzlV2FGskQivx0!mv~8ld+Xjv5XHz7-I#brQU>ApT|IVX#9+0)i z@P!pf0w-L;ksVVsviCEg4vmQ(O2%8mMD9j5=OUTrMmuMBX_WP&Qll!T(1~$aZ`Sgcr1?6 zS9->nv;XcHStcusr!4ze-FmDU zZB!amO^i(ph0-AVg>V4wuM~`mISuACM%{`ljJH$b91`mFLqKfzGdz6iJKYB$C_@(# zT99zsdfx}+dGLS8prZB8oloYMdKbUamd$W*^tWVovUfeXgoT`VXY!Hq)8oyf_m^94 z9+J2)#!MeCE&Mx&CU4RF$K}s%E3KcY(fwl8G@(-ZF{el)qoYYBOlk3NvDEfIQ0FG% z&FX>!)V3JRG2WnPCDC#ADRE)som$=1vcOY!3hj-^Du>^9eD;gg_x9TvejV{&d*uhT zA8Pe_-MjSii0wwPobI<*uEVU2XY25oKW{UwGl|4yD=YdvXt&)KtKF*tijbL-n)T~0 zGgD`=WU=)xn5{xC{6i+9M8_`&rVxT9?7wodZh|D4!YC0!HD!p>kiRA>SWkPLn}(@kHcv zJ#dpfDTOIj!c)^JCYyQ45ryArX3j=!S=ferUJ;NXl0{}ZPgSQwUJ+^7qYmpK8ZC6i zcjOtBn;x}JS7Iztn8p)F20ja!8aSyvl>~}p?FFd&epgAx`>Tm#y+#UvO>m@V0mUJ! z#&k<=NE4+qZ0`;&;5XC%uCnaDw##zhZjF^_$_Qtf{DUzQT_=#M}J;meG+r6fb z=>D<$TtDxM-5eU zM&1+!doB;#C?s)TRy{FIu{0_@zNNbQbVyA()n_>I*-!{6y!YZ)%;F5VxRYvy?lHZI z2>;pV{O|__sI`N+wcQ*5C_#E4EWfW*qC_OCk|R32e1+$BE#wv_G<5mh!&9?L=ivAd z4ngY+g6Y6r6fOd^P^+@QqwjbGz0W3u3Z$kDC~p=g6^YUaKGxkg+%6p0T3MAE{IWq7 zM?Mb>--n!&B$wUV322*|*)+hINE8EWQeb;#>TO{@WSIg{hEvGkw zyR6xJT-~DrdXsu#8BRang(&|{u%`S3Z{50z1{JCI(aIRCi4s~NgysZ zfer03GWqU*q?ay4W5cChoE1xK<1e_m#hwTf+Y>?wwkz$>&}xmE9wcG9M!Ub{8QSbP z@{s6M;Qy>DWOj3-pzgE?*Rd~#8P`UDN+ASuTlwIg`xEBlgi_m1m6CH6x--?) z>?-zICKQz#xhPVvu6HXzd?=+gU(Sc(_wU~#?SYiI)(nYKQ%g(3ymJnwGts&tXA@sV z?t4=9S?KD*p`EgRXa1+=OV|AC5!fy`+WEOV_x`>_;TG~eolDOo-eaq>iEKUe9sf>!@Fgk!Vd zvC(Y}eo4^hkmq$n{Ux+!=iORU@Z6JcdVBTMB@n)|cXI+HZTP3YvlP1?RHtD%SuHm@ zsXL1noCtBlgZuRjc-B?>a~g%k)^2RwcSpQpdp8%G3MYW=9TQAi4+`q*@A4VX+>~Dh zK40Q|0(Rx?FSDj~+3fj|B8bVgBEQ+GSf);IV|J;!W*^SA7ggWzaqSd=r&8rcXgVDy z)DxNp*&gpw)rC^!Gt}!31=BdT8r1TrDqe`F{m7O@^Sd3d7{tLz*?32(-qwuvQ?KHH zIm~d{skLoFLTb@z1F?#{Ch$|Du=s;ZgV8J7$@ApxefIb(uVnFEk@(B)52NPj%yK5B z=1y&}pme%ttE##>=B(k#??O*v^CD1s!q?z&RsNL` zB=HMu0(OJg9RB!0L?@zfoeEvO>h{RB*Oj%6)7KZuyHk@VU$MLM!2VuRJ`IHl6Sllm z1ZaQ91Xkdad|(f-2+il=fMMZ&pVr7@lvm;Uuw<9CIwXWIE2T{BqGv4ELQ$%|E@jLR z2_8P?``i(kh+oDzcUid(BquY&Leqp&(~FQnJ!gF#joo?e=I`{9ZWBKy*`hOj<^nw^4EP?=|xuOd|&N$(Zh7od@B}uaTc`m z?!AlM6P|D0O7~=XJP=ps)XzdeBK4uWCzBh74D8COjLE6xr5_PeByfzWI2l!sm9Q`{^&?OR#cvOBU}D`%uMJ*7D9ky$ZDRrYnR$Tq|0Fv}(B}4%2@h z{wbaPNmLxV2b_bCUHi2=9PQL;jgYa=7i}XOg88`qmA7L=(%@1ArAdP$XHC_DPYe58 zRSSOjN3%aR{v1sEU4B^G?Ikq%ruq3Nu;gsje_HhqMA!3px$`~rf%h%2Dj8UGr|&jN z*HiiC@#b`Ay%Ro`g?zU(+i9~_nVohRJ>k?Z=MlIdQ-r;MYq)!pPMIlP=_CuB4ES{3 z5MsFQJ+6&|N9WFZQiOpBHRxE>R{wcX;%Ii&X2X(`w0-xOvGCn0X28J0^w!C$HS754 zT7SF$>m#t=!0%eO?KJ*hm$X;a+E1|+81UB~IOG3v>Z;lfNxCNLpFen|n0JR`7`dOz zvQUznJAVqIWhb}v0}RE18;GkO<|!MKmOYA6Sv@MMs)fbdS*&vt{2co^&h>rJc;U*J zrrPT0#+oj{Pe&}Yky2P30fz|V;;&@CjmeE%dUxFa*da(t)NAz-?Lj{n#Ubu#{|}ns zk9+?nzWw<0o<`;kPX2p&YwzkihCyH19hqHx877$f!~R#E)YP2U@jSoEWA&26`z@){ zXI??qP^dng0FB#Zd%9|Si9pJ%cu3T-~2G&fkv&eLBkojc^i3@FNp=6 z0cT(>6B+Z`2byrWN}0>MgqS zdH6681F|tt(48ab28OL z=v!+Ad~vb$xBRt-QT00a1y}d1$w|$vlY9s3%@Ja&qq?5Te>R}s!1;7N2_d~{B=f`#9wFg5L`t^3a!KfNtQw!6>*GpA952UNICa*9l+PGIY zHynbzy+CFzfBT~qTeCZ@L8;ei;AG@@&m*J$OkyqNV&GuqH8N7=sNSvCy&8RRMEw zyMQU5*B^7lJfbmIU4;3eN5(`I*m*rL5C0!iU%?htxUMY-I1-Wq(g;X*w=^?IBaKK% z4c(2jbb~aKA{_$^-3=okAl)U+NY}UAXP@hQ^9P7o>wTZ+P7-etHqRCfK64VHf1lQ; zH8VUqxiZXsIY8d20iZ<6tehLJ@MxuGMz{X+E_1stn9w^z$lawuA39U6KXf*s{$uN` zOoC;LhXwRy_>;G{&-a-hSShN}Krsu@Tj%QTre3Q3{g>f56mBTd$W4n@Ku1?@SQA9! z%O3nD&EzY+9l-YWHAi_N>>5wkk+*aAy()iP+{9FaoOqkk$C+B4R`kVaof);7)_;uM zEgwHhnDzABZ3fiOO1(jzV08{J36F`Fk{)mOo6;C^_?mI&^Lch@-11F zDAd)}U5!~sk#}r!6KJNP_;{IPSwk#f==_{q;Dbu42$H}2lcUv_s9EE87Hhw*ga+a$ zX=4`b(cXf>(%4K+6HOpnJRc;={P&8|CM1PAhfb3Y=32t%_L$e*qjrFtNMGNqY3K}3 zgRk5&Eq=>*-0bg=%mB&l7S#i<6t(P6<5{Ct8RsIBH>bE>HkZ87(a|Rns{WDF`T8s>h| z0KfS-`)_?47>kI~oa;I9!^-1bt~H+l$(1-pwg_RVds*M5|6dvZlOF1cNVEDH+g2;_ z$A`Gb5d8`WG2>UZ9wdE?HkQdZEsm*J!sg}{U6FLs^P=c+W)y+i!`-qvMci0oOXd*Q_2BDw++p zZK;roU?H$!2xJ*>q)a2ve>mF{i}oPJCh4U>Am7kq)=7F3Z*R zQVmQx{TPgXef_aFV{kqFI^Mso9%j)N?iRosr(E#CW4cEyzt3juYRJiVYhr0yS(k-Z z+=;9kWX2}#iT(GyAf%96a0J-$+K-dAR#s-Glosu|y|(!(EP`z+f-9FLDp$POA8)3s zoL8?&e!KRi)Gx5Ri=Wf$Dg`_~36_b9$d7MuV&AVi_eQkbG%VPK;Bm|f2UPiPnbjuG z?Y#opk^GO^E8_fm|3WGX2 zkaD2kBN|g?JT?xwIi+gibjtE(gw#M}l#=?Iv|Z!tsN9L7YCbG#t5l11+?)wy)i7UW zvm!yw%wSR~%c~NvK`S0N9!qAan*G|kQL&D!eP`{KN}B{8?7-h|Mc-sQ%T_cq*XOfx ziBeo*aTOkLrSNbLH7?5TwQai)@qUIeG>N5CYOMNM-)!(~EY!OIh4_v}){7<12dtjs zVZY3kJLIl1QrS(7A>s8J@Gh_3qJY2^h8BB?48KG~6wh3+4g2`P1YyMNrdFqT)`@tG z&jplD3rFQr<*!lFC#8z&-BA$*LwhHy@Di!IQO%J~(g$nTYvprxs-e zOGX+im_B^XVB&@Gi8CgOzS_Uf$&2pyY((c4gj)&+OKq9|%G$yM?n>D7TYJa+GQ{Tl zGkj5wvA=AS6oC_)u9eN=b9!4kZzdopInFN`X{P4c?U7zu2;@m2eXJQIup3u8(fwU& zFPi#u=1!eRwlR?3c?Rk)RDE)>(i8Eh6QZY4#5Jdptis+WaydTR)(y+9E=TpYi-JV& ze>O&Y$&jxgza)jUFMn7UDlRJtSH0VIn6T~h-Kq>&YgxIcQrFs!RMw#_Qn1u1DPwww zW^bBAe(8?qQ??q2z&a<|*#=NT#)t(gHZsLJY+AH=QrA>`d3>17OUJrlprk{+ERg@- z88(OTP2DQfPAY!Y|917+yDW*Jp^bqrkWV)^7-vvvI&rz88L5h%zS1XJ!!IF4wJkY3 zF^mkumqW^MS`R?%_chP3xU4KVJ^j^sQw$@TNomLo*_IbyQivI2Y?7XgjwMOkKcMhW zzG~s9QR7xnoqOt=-O-;wl45?BR4k=%HxePPP@ylUIP?bw)q{ES=j?C;*CVQleWm-_ zrIuN}5f}BD7%sDTE!)Pg(~Y|YkM^-6%ggHT9l0xy_mZo@)b~Q)s=k&YCYBcVe@xE^ znelD0j~t5Nfik zaCOdS3%?g8cJ>74Hd$}Eui4W3b*PFUDL{t3`u^_f+OuQEh@{YgaRphTR=3^7m;8~h z-=zX3uE3d$)=n2>$C8njt|_Hn6ttc#1)$ppq;Seb+>q*58h$*eEEn_IH;qKu9l;f5w39f8cqvR!KZ-fsm8 zS7}xLDU>blJc7K+sh_ZR9N`)t2K&Zpqk-ykiUAOo69FM3_pna=2B{g2RdBC$yK_-@ z?Sy*y426j6mx6Fy4GtYZbe%sxCs#MUeobO53jsSgNZ#KEd*&!4(u1JZJCsi+k$6pu zhN=(|QBnBO%|6fq0{pPV zZQo1hHtXDd{e*TPbE}!!j|vLHs!eTM2gypb0p?} zII91guQ=e0yr3`MuSs)r`kshqe?m1Tz+hOt8%`)}Z1m_#mSvVB4fC4bI5#C*e3wZa zw5Lt(y8<^FN5E;nhhWyrlRkxL{Ak9+&th%=dvV@sZyPy+8FS*N6ahl%Zw@WQB`ATz@T&Yujd1&z{oi5B$f z;~R#2G=ufDV0LMyXcPoiykb2H>q}|5-WUOSroywDw{6q%Hw=}4X=kh@XSK8>cP+Q$ z?$e7_&(H76wAV^M%Y@^ePCNK#M*szx4Zgx;@xzQ`27wzuMW*dq+B}++Vpg#(4L6zO z7cSy;KJ+z~RHis=B?~sQve{aTF|r&_8^IQLaWG!UqBoLV>jyt@1;-tEX3>SmRonKl zRJPg>&S)|j!*Qro6ZE3wot^Kn)$vxrp?w;AISva`KELsY^Qs$$DMMiAw3li!ARiyE%fH#r8&s(iR3m8lbTFRniKEDi#5;T-9(&*ZR4{;c? zrn_}2+dL~jSOS?E+AU**ablz53yo7i&AQV9><*~0f8pV~S-|%PXI`|AT&XCRo`UY0yBpP_~_`$%I=H?C{ z&Z-&3fN}f;j(8A=6FbAhmHbOHpqlm8Yy6j$;{=V4!}93+%*x`%j@+gtb9;*nhA5Ic zd!YJG50=5?EUgcUpLxw?PxT%&n~DXPackU0i1Q(RcH^zDU0_T0-=>lw74mptOnYnB znB~Blm^eVynp=|Nok5Zl5c_gO=VT(z_iLQ*RZqEoV;CPe8*hAU6jC&45D@gT)$YHv z8F0E{2I3{c_pEb#E?!BmSOVUV@#`}?TMV9#pSdJ?(h%Uf+5NMdCn35|AuWz;Eu}V^ zbnD19zTzjvBvgmWvZo9Qceo7&OVX~%l#Q3th1tU zW-hcZvHw&WU3^3Xbp;T%aO!jd59iPnB8uySKK68{-*?dZ|`~0edUW$Bz?ujZ5C5psw}49=@IJ zlVsInz=>+)A#PSskR{|bnQrx5O4R{ZNkM)OaQ%U-1j%)wa0{fiz=!69hd?QoX|i+g zY$oii>d_4iUqsIn3|*Khy4i>}UNWRUQ#k~WGpenoe>L3XD2RRUU~latki_e1BHZ(= zlu`Ju8wH@UkK69GC2k^AozGLDyGMUy4bqNZ$>GoM`W_(}9 zY&AZPC&w@ke)nBWZTw~G@&}3gIYf=k7Uba{pWFy&Dyf442h zeK>qE8?ME|NxJioAfK3$AxbfXmQG;3b{#qa_2fM37aCZ!n1XdfhVuJ*K!_f)7)HZ( zHsWYNJY5sXTDcsQ97I3%W#cOld?rYkPEQI2GKqly83r+qNi=PQS-pFQD7H+Pg8VC^ z28s}u#2NXGS28edvwH?|wPD5xv&5ztJUqcntsj(z?bf_$SUa0#T7y?t;6k8h7I`2YDo3Vf?a=qzvs$fhRdNOiIP-}?eGW4BHPCP-7~#G0Z4Y!0e7ykutV4m%>Du*zEIqS0)B zKe5uUVm@Ko1uA)Bt)0S0#CK=vQnEhoWTn2*C7{B*PkB|1;WviCW3xtx^Ty@=?3D+M z$3rD!^MP^3tAEhg#%)8L8*>nd>weUd1#AzqJ=E*h*&zFEW;nfh{kj1f`CK?2^g6|6iwzB@u>KoK4&AW|JL30C zgPs)dTT@Jx&!%U6{dio5sD{p}mg65kcXb6C&wFW~TomBt{m)?UAoGD$x=TNEz|?BpJxf8OLn=Q~5v&fH6vjiNg#S1GvH&L7>JFx@TXB~G~ zm&<;*EB6;3p6f%5ugG7Sod1|Mbf1&&*RGT&S4w>&Ya%OZzi}(kZpkZDaD-EVcs5(mG^5}fAIFA&?|gVsZZ&!19v-C2BT zR0~YecpZ!vIHnvxAjrxL2rAe}*_c-pym{ghxj(YvE-4!cP`1c4~eR|Pf!*j$}bam#U&6N8E0f$Rs_=%@i86Rki z@P`Xv9@>ny0Ym|I158C(tn7&iH7}Eg-+vHs4jG{G{yOI!yrB^5crb{6akwxN_>{BO z_gud}HMZ7#h@jc$_B0r;h)6?slAcy2$+xFxYxIwyT86Lu1hO^MlVs~Q*?Cr5ke3;6 zIJ_0pOX5#Tf<%>LVl1QxE7E0X#4>Fspi$=lB<@iDsUjxtB%q%^#1g7eC$5 zoRb3gsI~bg2Ev!&92UD5!{hLp&v@xwA{sN=u+C@R7rfCZ<2xf3;;yp3i8{h-H|?yP5u_dC!$T7h#QjD<^sXtThI> zh~(=+lXoJRX}KNV65We@gGp5VU?XP9*C)U9@*j6x9tA@~o~Zsn?-I^!6Fx5glci<6 zH10!d@+Rahy2QCRVH7=h{_d&;;G5e|(5V(`g6ZAxsb@$TJz>CqUVSx*Y>ZIU<7}`X zPOZ!h2-wEtfbW{l7}o}VV%2GZShXnQU2*L202l-e-BJ&d`i2zCgp?yo5Ub3wU(VtzdR@U9}!-<}bV6ERh(qJNDuPfEcvE*JIe$srWbT&}U05Px1w|DsJ8vFMsD17gh2wrZ&-%#+>~lx^kg=GCzt4 z6hX15L8hqfC2XfBv{TcBjPkO(1UCO%w!za_-H~?6L89;OKW}i)dYvN8h~s~f?SNE$ z{L4V)<@-!Giol*~vWdDk|3PB;@d4NI_V9RZbZ+WksU)Q4kyEHh8Xte5U8xVyKbS0(*;j#a0%7zKM&@6V3#}Wt%&eUQMIW2lv?eP2^so-^ zw#Qk$+T5>n8W?gB*ELK#9UtCQu^H^^+ooU=H|G}Z(1yrDr10eV_Hk5lg!+{fUO4|f zp|!BEw1(*)EH&mv41v43%uhR?C@CoXZa&u+Fm6kK_(mHRrm%Os|Hi)IYi4@UjCuh@ ziqZ0q_g6pgzM*#r{U3rzH^S4c5djRMVvmddD(!y>$OS(%aM4|>e4DcYHYL4gTXc1J z^h?yhzCQQMMe_Tyv(CpXjwRUP^9c8Qk)dJkdcigr-4r{jLI@z^L=T$It_EllCQ?2`XEOzbq zALEiz>B+-2OaV4dz+tYNw*COfr8iWnu20&GyvETF6!0BXQ^1ni97fJS)FS|wZLAHXQ=bVoX+sac;CVpGwd zk;3}B!Hyh&L!D0N`3+%PWEjM_niXy|h4l6?#d+>6fUv{F(=g?UQJKPuJO~OBOp^Xg z{6BPBkJ@laT}$}%{*23NClWAzE{+AZhb0Uyyfnkn`|*nGl?=IZ20dC4-rCEN%vrh- zjgWZHobZ`f=Wt;l0o|G}GY_@!%t|mbOPp6_(Pr%y#X3WSC1v+$zeI~A*pM609A;qw2*;^&r(%F46&lNx4Q|iYA%9flbi@v2WV$R%vkc7v9gXQ@ottbJ&>cHbGoEp+z5 z2G+H1Xorp}dBWZA=zT{7@cA1**XW{i#lU6Lg-iAmw)Iy1cCLx|Xps}2%>LE8YyrIn zl?L{fbCD^4s*Ed)D_TwJ^Qa*C@K$Y9Dt>(LE9=D9DQ`VaXVh)r+<|N z7$=|PL`k2b<>AZ_niJp6KF;V+LzY>*FGlscHPUIKzc=bLtytcT>H(ADduA~cfRU;p z-hcU$0y-uwrc5C^pvR0ZPhNk*Maso&iO90Jjq@M$TR7h8?2_TjPzJIy0XnKod-sPM zfozv_^kC`f6rk*Rs|fb6BzgMu-q7Vf#?WI!`R~Q$h7Z-&;DD7(orF@UmbB%o((#kz z?n|Piq$J;sGLKV)@r{F6iwE`Vs$Nre0S~{!!@V^^>PMm6o3Rx@>&6eqOU80ZpJwWu z=Lq@S_2AE;UzdR!aPqX*iyzsmq%hY8WyBS44i>+?M6P2!`)ZTBb#Nu5fJ?Q08cvNu z%ak^f%2Axe|n-n2@ShOaq&$f)0rk=~nUEN*;<3T4_wcRIu&D zsz*=&qXijZ@orv1_O~6#&-H*TLSPA_k4?|XFt7YjvSh?isxk00mlB%kp3F-Q+gnDVn4)YFON~11TZxDV1 z9;)r?wi8l_#Dg495=z^Ww~F&$DFtdRn;bMI4NK7syT~~tKG8ipa2XAN7K2ju(mYPgP*0+jgy6k^ChzkEFMS~}k*_40;%e4dR#)Q{SFM8W|j?zttCg1OWJpYqY zZq%4MQB?5P%|o+PYxn4|D8Lb4-0$gM9Bj3U5YH+%&hrl&^P-54rA;^_tttNKHBd({*pcQeObsiP(EJS(vRO7BGi6+L2L=C?T>=4LYeN1*8iv#2eG< zmrVD!$E@rId18nvyEmWXen?-sf`+}#tH{eXmsRiW?WM0vB0TWFVZJz69*cVR;-7Y8 zHJ?_%VQIL*qb-wxuAtC5qcJZikqQEjDYW=E3R=8OIaAySNdwA?1`6U%es9D%Ga=H% z{LawQKGa0GL1(IMr)@Osz&vArH}$BRFYP5BuMsYPe>;h(nx1_pVa^`02i~3B>%R_X zIhQM7K(;bNHk?8LPSiN#yvw<1UvPB1%JS7PuA*C5 zLlBJ`i1urG`Wx#3;MH=cAPifRe%mreM;cw@b=4A1jRDwthG8#~F#%#4VAzw-A|Uu0 zkRT>!)B08Ao{O~u zs|#Bugs91)1U^9#AjQ7$v=F=Wt~~ZkOcym1YZqwX{%YR&`AG!RbNX+;Fu#XtJS%l+ z6!F+{?N)(~QA1~~!AGgqdIH+O;IC1p#WF2nnOk?Mw{p{d=@+i|I8t)8hTD#CK}aI> zEVIUe)~nIUmt{bm+xCohMux$cB(zzlc!+tMoJ>Y9DNarq9%!AOmLEgo8N%(WU;q^W zKN@-t^}UOZt%L5kAKgsgUX>vpgr6#Js3lL!8Z#sj@{b$_7 zDL%nUAi|#hpEuw$OJspWk)0l0pJnNc_9GYax-vuMQRefcf-xAmdF4qphP^MccNP*v zjTMW_@WWr=*4_5Sh&5c`=lDN(H8?C_^sin^_~Ydj4)%}QhVw?eJ_|*C`gBC-c9a*s zIytgu+#GEv5l4;IK$l@XX^7~t+dW@)JO~o&J9ja>Y4G6U5g3m1Kk?J9B+b*M@Z4fD zyFfl>WOGsu(58(5H@p+YGX*dJYYMj-2Bwtc%5m%vYL^q1?OzwF|K0Z=>~N3f29Apv zW%BF0mAjW6cYR50l)C*T{+E}!wXVuEHZtOTP#Rq{=}7Z=fQB6D3K4_1rB9J1qbU5l*Xo34xJ0QP39B zoE$Vc6InL9yY#*rYTgUlA3RuOrkL$hx9QIYZ8ZTi8-?6erBbC@y}nV!b0{FApN-oR z!ptsaVm>v>9LgxPZeyMQ|GrEdHdKl&0y$bAkE4$Z4U`Ao*0}#PSXNf?GBPrr?FiwW ztSGHSLk^k~)bA}H$ZSkvhDxp1napjPM}u+2d$BSFCgv9*D_Ih$IBb@uktxYQubhsI zn5riBoi~PYupp|5!V{Q0Xg5IJqRX-%H0BhX(YYoTF%v&39BlF&Z z^0|f$U1^mkZLyd8TdlI^O(_Doo2jM@%BH!b6A^Hxt*7opluv77pF=;rrj3{W9B+j! z72jjsBq`{b^wYCM!0P9!&h{4d(VXBPi8nL2(!XTJLd9z7pwT(k5zV*}_nqPmZf#=y z-9ppW7e1SkCwySdmerh^k;Z@sTYAW^CD5VSD21_VVmD*#db4POqhVRwr1pNg1=cMD z-o5tp+3&k`EZc?pK+Bmb%YpHwe>$`oJxiyh7{MCfF>8TmcrnzTO_kvSbMS#tP)>a3 z@=}Z5q4zo5@JWB3 ziZkWPeqRC$Z(IV=nV0vix1LY{$1U!GrImT|QKd>EJ#Z}I2SJMDOTS81npv5-`RTJH zC%XG4q(f(8--fA26U^YGYZ-(t?l*1ce-D$2=Omtk?KAkF+>7oW9Bu(YsW9~Tn%UYJ z0=xkMGhux044{nitdF2{CdA|&%y4_JWac!q1+u!Ji_37(D?_1I zaghagLHRx{?L6@1&xAfT+`&QxMr?pa`wd*gl!tbA{R5Ii=YlKUB#&nZ z_{KBIkB<+*puIf81r#H$04l*HUtS%fOZ$0|7GN}ymQW><+r;up-cT#kIzfH>T0#?P zY6$pAPWRzi>8)=e5!6CxQk4&I^|EPOokUTBS&*^R3((yViBb!mH6iKVE+rd zwUH65y`;~7{_+JLYhuY58h?y_J%PcDV`4)}O>Mc*f9`u&X1rEfGV{-82b(n-3HL`9 z0P?ztnK`hg64Vccq*cFhZ~jucLLVJ_*h#O+kt+L8$7R`TheudqC`TsT%X>+r{d~-U zS3siQVC6<&*=7Hkt_auLL`)m?cVq*yFhDw|UZ%wiL7%hki$y{tQJ>V$r)I`+? zc8z_^P=W#OWJ3gFtXYHYV&~;?b5z{jwu10&R-Kh~hSw(Mtmw5!u88uNZZdV<9#%e} zd6Of@>kQm}GtKET{;I?o>9aC$*QccD8p7wkq4H65RmI-om6b7x=(hLYS;gT32MW@H zik8~=iyUQ0UitH6CqAddeEm$X$8gE+tWd10TL=FnV~KO6WC6A;$=sFerIoF_D2{K9 zRk*6p4G~fzk)6UCpq8;JKWb1=-oyFG@qW9DKwDjdM`GWQAG_k~%xLE(l74Si*8dJcK6Uuu=_p3=c0Jp26!##Jw) zq})pRT$cZKy6d?+UEgT_`(HhCaiRNOdJ4ldMfq@8Olkvg`^>%& zs0@fj+#yt5Zmdh3_6(MXho_-QeMT`lj(43mmVjOTn_RTtBmpx92z~t1-U5uvq`rIgd0eV{u`X|wC=|kLF zGTzLXn~iI7R~LTH?Usn|?8fL6B2P{1VZbk69ZP0`osFN{^NLGV{03zF@J9!Jl^=CA zIN+b8SGS{9sa=suD4KJ?fcVi8JynkD*V6V2CCZYj0wO0>>X<_I|OvH{`6&;8ozR3c#N=_T$HuxWa=5_)A)5 zd7wa^qpk!P$%Q`=Q=koby>m_P6tp8mS`o1k0)UYkP!UK*afnk2h49@hX_43;rx2P! z5_S7damhP;$(Bd|hZV`I4qcaFYj^s;q(((a=zH6PDfEPd8)A2LE!Q`*9bMO!xkJZ~ zYt-w_FQ&P=-6$eMP5qE#PefW;v9%MqcpJQ1YtfQE8L}|g&9MDaaHE_pGHei0K_r0I z&Kf)n!7il{lD8`X5RNoUN5?P1E<5-$HUMuZ@mS`8O3r6>vR$bD`QK&T^kw~b#v2eg zk)GZf`}2mkkiCEdYs&O%Ic}JK%rBLL`EsyR;Z;=9J2Mv|G>i(I;hLLTK3KB`u$jaL z7nGA1Xkn_(uh*05DKA9R<#B&bwld>IUHcO2R*Wa1ho><)JvDT)OL{FGI5hO!{_$oO zSWyCUGsR)M-%t-X^NIarHEIeNEJ<>+PR}+=+HE6TtQEt4yM&wmzvSJLl zP0atCSn7ctw*ztQ{$UFpx0K%7<3$Ap!NsPG8m;Xv6-j7z*e2|SWd+&%W!m`RwBQUL zhal=tX)5_zIhcLPij*1T%Y<8T3Aal-drgO z1S*)g$QCfk3%|I|QmFYEE_Cc`FD^DHgDcV5b9o;f=X=-qyeD2mB0ys)jhs(N&zdL? zhm221B7}Y#LlIwNon>Xb9~JzASyfphr?zWpYlyk{P5&#P6f^p@O$yHzB>n6!AAsaB z>wL*Sp{D32HG@UQ%5dbC=(6FVq2%lnZlc~9#%^oyDzlIA2{ukH&P&&5<^TF+9)%bs z`qXdtvv6ihO*nR`0PP>+tDdoBV}wuvwB#%!aaAH>6~qND;y3<_$F^G4k=s%`}Q`kvr&2j78dI__MaYnhHM8bUp+;Z87$aI1YGJ z85i5PC1%r;R`6MnbdRzI?yBc+|L4xCislYW_$DQffeWbn-%*6=(dt>a`euDwQ@=P~ zL39N_`%0Eej|~lRdiSY0(T$cc(}Q?mS8L(PiFevT3VlRFL0xRrj)+ift&yriezMZ) zH9%7tGyR;Olr}J6Ez_xx|7W5CCRP1R1LovNJ`$v>YyE_{&x=sg(g#D8H_^!;YbI4y zWGLbRT~!n{k6D}8h>Fkup1_IDb7zygRfjZ)wXWF&q zDQMrgCM`H-cw|cXqSbN$UnQMK7F{aP+wQv$4H)RbmF%^nZjPB67ss7dSENxUDD*h9 zrKgO!_qlXA7WZ)Rbc}zzdKS>xIsD!;Hd`AnowuC3f$)P?qP|z;)7uZP!R5jW(LW5n z+)!6-sDEwl*Mj)qx*MjAk8_}|FqXeRHNq|IrRR<L+JLhv^h=%Z4IPf+?&s%oE5zMVpC6#%cj>wiz-6 z^1C)vt4zSEMMQk;*Dst<6W?KFki`tY zR@b0Ct zR?xc)H5@Yv=J?odC$W5?ZuMdPn@6%G-ujv3k@uLP6zW8T3iv9-)e?G@8nH4*@QoJV z+Y5)&90SSDisMJTwronPBvU@cJ(|E`=?O9+y)v`Uqq4)l5MC72ej9Hg3-|FFZO+Lm zp!x>01-Nex-vra%N9Ge?;#zGci{r7|yi)HM~sGd@b-kTnPNfNO`tq;*E%lTy6rMPY!>UOOfeA zcc`Jy5{w879kVarO&QUDwL$+zp}Vt_r?TzB2Jq{zY%M>d%5#|D@fKM)F#l+k=E|d7!Dr?8`hOnNz-qbVO7cjil$a6Bzy$YG{7~(uL_}xFbjmR80_{p&KeZz1 ze9eA&1+Swt)zjYvP%mo)RX^h!QtI4~o}M9wcr?k~PDT`^@fzz)X|b{Hz=~SA|8sHi zov|vei^W)eMMZG&wnbqr@n8J~bfC~gfu(OE@ofxu2=6Pq^d!3<{MK2YiO$#SHJEvM zJiqpYzu@K(7{}r)xAe8mg21K8~k`;B*?EJz(;?{(*Bo`tSZKOz@@-bH9(ZelZ0gzht(PHIK z6zWDkEh|zcpinps?zqJWxCiwAD?p7!W%Ch+FQQ0HI0EC&@Uzy72mu-*r>s11EYYuX zznE8khZC@tQv9#)WCW&|vLo6~{mO7t6zjRr;GH7HEMT%w*ZRhv%M)D={s)BgB3l9e zH*tGbHd}W}9K~w3Kb|c$);H40nbCT)#crRKTkv_20^_@Qo8Mi_`!^8UHPC&pm zudK;vD9MMnfN~JVRj9_qCC)EL+Q-MwKW!Fo5wAgoB;`%-obx!$)mx(p88p>%c1JRS zx%x%wQcFfiX_<&HlS@VbF}?p;@bPIM=L5Tg-~QI(MNQmrtQPC8gzh~fqlUbNO{9{V4w zxF0SDv!cs`%q=vjX6x$f{dR}%M*mj}0Mz@zE7lboey9*Yt;X>!ZS8C+qPy}6Wok+z z%Bq?pJz6&o1(0W3RY}#CC(@;gL{N^FbtB*Pjm)dP`^y^Fj|@7kNX*2+cm&Dk(ccG~ zWV+VC+OV_PWARe~$THOha(Cys>d#oQ*a!{%*Hp z^>IJ6a5evWTFUHx;2$CGbD4;R3RJ4)Y*hPxd{vU|FT&1V0Tk`5iU|BN#FUChB(V}d z_ia(CsD1rj=mnfcm2}3jP&yOvcJVBwOIQ$fCiGQ&=hXFGsq$EVa(0bse{4HHFZyL8 z#04ReT}_;5qf9Xnt*W9{7AiFS$<;N)ZlRIebr&x@JbbR+nh{xoL`A3$FZr{xknv_ypqXyr3*nTW5HI^h*;0NCw^cS3@9YUsdmo}z@)3Xl|EVDgHz5r9 zOmCD;^M$tejqk(&H^w2Lsgk>!ad;F!-jb+SXboNqbCHGcH;TOaDZ+pa1?|zKNDC** zgg=8HSLSkw@b$uUjFfd&Y>SJFhtMSgj}wcz!9)c?S?t(#x6Txdh1Nj?sOz6vGzorn?7YX4_SKY|LEf=fo_2wDd@zxh+g%~(wcl%raeJ1l@m7Exsf4yIi zY{@dk(@@3@MR13`pj=;lxVH`1V{o@!7$yXafJa6xUrEVj6v6FU`6Z3vSe#8yX4Q!z z(Qmwc^s4i6=UjGxUO2VbsEK*9d(d||^(EMhl}yI(gb&fQn9z5s(R3lQEZ~ga;~B|k z-|61J!K!04*vzLL&ld}+?n@jeu9jB3qfuzz#q*4vrnGS490tPkNoLPqQIVOS=F0(A zjEkd%fp))J5R^YmA$+d!@ref@)b0E^`AgQ=LvTc=()|3#du(jBf|8Q7*h;GT=4RU+ z7}>fPMiITVRkD_2a_rBlr_bj$2mn~gFin{}XXlyZ9jy`x=XR=rWW3xi5H~{a6xq-5 zm!c>>R_O;nOb7$5Qfw0bgYJWj46AJFCCeZFAL)D1VDh;@;P7RLB+R@l;g`Z&1>U$U z1^w7`Q4fh@__d$d^)6@A!&8oNp+{d09Fu%}`rg`hWV~D3!LjHvsuol^9|yt$5G^%+ zVjwA^x$*f_U^cinSTRTT$F!cGHJ+@+`A2(2-Rx)5&0A>+gpm!LLSxTznZDQ(a)5EB zZE*IQ-f0(K@7+t9jUNab{=H~S`h%8D4>Ca{%m`Qv+oR3-B>cg^FOC2y7C`FH=W^T z5{z~SJ3utqXnF^b$fC`~!`I!O=3aC2YbqlDyS;@#UCngUHZWImTm4(~vS>iG;HmU{ z+>rXG8i0J!hSbD$_}l%n->`GJe~H3WhApYzzDWUg1@)|-zZOSpU$XA*AAWkcyDk^m z(y|y!2lzLdoE-qtmM1R+0Nqeh&0t#{Bd8{)cUg+F-?tsz`_hd^IHM>Hu2kzpinR#EytbLf6ba?R-rLKT z<47wB7}8i5l4tJQ9R!8rQkoyK*qOfXrjj zmA>x4m&wi?04qn4CKSu9_bc@7d^Y#OO)#u9g86Jr89OfatkL+!0LYcT+U&S)+{8qm z)FKSW&pFNyWQzVys@$$?ZfhH2XVA#S%^jGCsUyr(S{`M+9SMaQDo6tKS&UT4e5?V~ zkKT+64E*+cLVw57WsVooWt{*}-c7K4S`DJkLd-q?b75*M=Gcqc_^x}02@RzKdHWcs z3(Yc%wimn_7$QMN3rgysw%gLSa(jE``H$!Z^Ge1Bk~)re>~Ko zDWPGUqj*FURBFqp&8U|=HDvx7iuHEIrS#Y9;b}4-_v7u(HK|k%1F(U@GdN8rJ#+gp zpgobR(d{Hv=X}eJF^k*<*vrhy0Kp_e!p*bm8-8&YW#QOxfsE4{d@8+LrhT9`mfxMX zrWBr@SqaZ5-ri=LAO0;=Ne@)20%0_z+CKnEN6k$%FEgy3;(Ts&cd)2_>D+W^tGo`e z#VC10>#_V`m->Qj;N0a`_ZPm16T`Sp@mIgvfrpcV5A!DmjtX8rlPqT7zL$VAZS41H z7K-03Y2p44G^%3lsR}^BW=}Zo221G94Ih7_mA5=7M$YJ7t<7kyuPQmkI?^@7gS_)z(iD6~?NirMwxaj0f1|WMTRM zU7LU)0kSPz&&R&C)n$HS)keM;08AqCVd0+EmmD+q&Xk{dK)$lnH`_5({D$>aFPFyskaJ?vi;t_9}y7&1?lc?q;UWNsX;(O zx{(g)4w05_i5a9tx*MdM5s>a2knV>6<@Y^)$MLeo1{=UV_qx_~u5*1(!-w7nqq$@| zIaDZmkgA+)R_@Q39k0bvqCiLd1bQpN4WnJd9<+sCV_*%+PbOSEnjE|uj`5F|X48nn z_5l(ZG|YxZX3j*5CDfU-HPLm4(qgUW%yy|U_(MTP2->>5x>s}DyQoN<^^>3p*5G{e zCS!Wk1<|Vdy_~jTX(D}qH$QR}yRL|F8Vx2oZoOFQ8TjzHnom%TogWChR;-3~5!E>H z)G4xK=`_(`y5An?F7XRLOvq54C((IgZ>z;yq#yH|H zdT=oFM_GEPN%Ol?Fo~?yv7e&r+nB!W7>8W`@;&9!?id(Xk`}gK;AU1->tN27Pu|_k zaFmOZ5ax__(k}O4p}J{VsC z_-AS$q~zse5o`4ZIX5#vk?HDpL;|%Ml_q@c+QTZIaYic%Ao=F0pP~UPx2?;!f=rJ{ zB-}UoIho;dR&VAwnM)umAP%^eNWGe%2gm;amk zMysBEK^QIICkWN{$jqQ8tqIBX%H+wdfS}EsPAS{@>bR#=9-o6Fh@AH(rq-T{!7Yd& zGB$myqQ$29dyDrK4wv9FTVTw>qk)avWF_j{q|@_Bpv6_@?u5EzhG zS|G$)tNg_gpSfI%tN^>0~e>0y6wNV^0Z# zc3x>~BwXjWETB=W^SI}Ins^L-?MqIO0?eEjmQ9Q}E8gU8ipkiLV{yFutb=cwI2ho2 zGkv;hUg~`jrRR3Ff$tnJJe?HJ$B!!UA9`-(MFyW@WuZqPQskUfpr_GOAv|zGTgREl zh7~_C&B58t)H;7E14E*s;jLI^j%r0brm~2o>4BB1Q0+__#wuU`e$fL?uOl-7CVgRk zQ&Yk=lpsL%Av<_ofkCFH$I5!AT;#p6U~9Hc5;ZTQHP9f_)Bky9+SAcX)K;0_3crv~ zGmr3X`b<=4zElbW1th7L(mUv8za@sE$&i+4{hO$_fCbzU%^8WXI9lyy-!hC$iLx@@ zUH(v`BVn3@NB^21Sz&<_c1!jpfD{@SPPeN|^$W=)gn#V4p__*X_N( zn~`eDW+U?rKzen_h(&Dh^t|U48AqGtndehp_Qma2daLRtO#;S2}CR&lJxzCKqaOgOx2>tj;hYl)A^=N(RLYzAU8*vi88pIqe zhpRiUCgAFv0FW#?v#(i_pc%d+4Ypbj5aoyCl*p)P2M^0IP!g2(Z;$jd+(#PpJSRRB z8?=0Fz}!@0#&@6y=0;-xiz3evHLz{E7nSis(Y8;gyw_IW#tS`S0c<`Z(60YVRdcnU&i1$wza}lR zBfcB*$W00~PYpV^d!qd=4C$Rp65i3DZNJ+wgNu*Bm-h?_cSUGiJ++4N>Ewi$)t zj(~d7x88?tN|*ERFwt*vkAKTzk>M=xsp<9=A(y_SvkjR%xoJ?lqh2D0fw90ks@T=? z$B5-Px$W;2q_aYb#FXS8yH};F`BNMcyPS{DGDkLcUDwU8r#0Qb2AaA=yQbj=KhuHA z^vV!tri}I zxuMpUThbI`A{Ht@%Uk^VzG@P9zx-kU>pvFX65Bb?%E#nd+18&1=uW*Nfr5Vi{Q` zj)@(~NB@i^lVHdv?yP!Js^AA?iHYq9yR3eyC!I5C#i=x`S`#cE3DW979Km7s}TtS-loRk>l-^*$^VOi?EN( zhlmC{kt+%BxoDJVKbEU)Ee}v66Fi;|IRo@Z-{Ph6fDddbC;K~PD|VU&Qr1{`K5&z) z&&d4sW6xEgw*@atEr>#8BPuVMTErub!L^@`KyA(RAE62kw||{{N17&|Mek@SD6okz z?2|@jbYjlc(mZ-#egfNjZ}S2h+xha4x`Q~Lp7zk`6akYe)cS#ZV{O`$Yn5#m7uN19 zO31NW(9lq`pXmLkmmz4P;#qh0z4WQuMfvs>a%*=Rw0$$?VdiW8wbC|!?ZIamn=I)u z90`QjQl!&}bV~Vg;y7_S`^hq5e??aOif8F=e^2PwSimFBmQz(iY%FeJZ%&}2)t5#L zHK2>XdFBxOU8Cd`1oF>XH(l@ect_CIXn||;WdVytrl$zibub3&_F0l6^hY}!Y4%8xgVF{3$`Bj!ax_6 zKo|HlH_~VbX|D`;1XUasik8wVs&Kzha@(Kn-?~I49&WzE)T*@od>*Y-%>xe4^)6IZ zC`KM`De`46&%{5Q8Ysr!pM(FK`F-pT=j*Dz4L!CAv5yFj}&;P zq(ny{o%Mb_yRJEyflZT_kI#}Q>&k!2q_Ae?*S)XL$wAu)42T(4#96u7MO6tgK3km` z&ikHcqfIWGqRG~2Iy!ddMro?n*4Zspn4)VQKKMbOg`(x;TSvFm7xFzc_Y4IbI_^SECZj)^ALUKp@keBD{*S~rI~j)S!?3P4x$i3AfpPvbSO zNwI5m@rDD7%U0!z_eKs5=rC(9@5X0r1o8AVUrporvhx0Pbv(hWzid8fSXmJKy*Lw` zIS9-~(z3Ed@SWI`jBBBq9WSP+))P(Iah0a%PM`shkdS^HnV&(OdD~AWW3H8GsR*u2 zSaf}n%Zq(zx&75E(K|Z&4Y9;9uv6c;n)i6#ulJ(C+)`*Tp+?5}s^`)Um}jw~n!Nvg zZsXO}iY8-A2k%9>KnNJ+M)d2pUOH^iFDZkL1AqB5{M(-Z8bksY{*kjVmRq}c&W1WK zn%HM2dijjyCy#ewS8^eb*eAenQmC$Vv0HU|cKUmCcAz!zX#;Zc#^Yvgv7@Q9IgQBBC+>#I zFRY=;{A8unK;-&bj*SIQ70cXxLMGsF@L0Sc2fP^(Dcl0DxXGWSPbT;C8?+HOFbN%V~bz7|F0>y?hp&;Q#dnNYXk_nGn@4lbDp!w_lo z(sI7uzCC)l#?#1jWULdaTNbV?y+bAIKau%srOa4885tFolSrE~I66C))}8y7dE-6v zI&gQJ_Wybn&unt_Gii6R0_Gd~LZu{Fj=}Teo{pc_#X^vZI>L^x=lA05fTG}HUsGvA za;i=cWo3c-`S$-lCv6VL z>9D?Wvol2O)%iy>?YE}4$Eg6JtJ4!{*jHEp2PB3Riagh1nNp3y*ip=6B z*=~2f@p*1`UPITscGZtynmPBqkJe5ZK-O})I}^)GHqY;2n%2OaDR&eFi30V0pAT*l z3mCydAULNLA3B23S!Sy5J@;FY_5y8(C=@VQu~u^s^e?|7 z8?2zli?_D+-}=`l8k|($fj)v|tM>qLzg<>3-(Qe**JN_G7^YQHHJEJ*t%(sIIox6v z6>X`mt&Ou*%z96)I6kB}6NfwHxWg#@ zYR6hy>1`VQx1o2eNY7N3iHdUAu+Teh#=NSglzlj5NN5NU%5z#4q7U<}B-8TG;)X+> zjUMGBW;f)8Ge;JO2;LY_KL(;bRC4*X5uXI-cmHi%LQZWc{_LnHSBmLk@rgPS4w6CGfS$Bt}@S``xw}#EV_YT+I*}(q+5;y%b#~&Le!s(y!N06CJKuanY)5aub;lma z{)3GLlVGqWT(vpER6OZnHKhbN9*%k`c@cyOT!jBJW&sE)r=cb|{gWSd0nC%I+b7`o zl-}@eAjM<39W2Xu69JEXhF6dF{Pp6+QPd~Dz!KfsN~dm&Mdv~9Z5V$#GSfFCbJ3mZ z=6nzQLdq*&*%teogCkfq*#bM75up(;k1 z)=#oyIS}Wp%FI97=0SqF$z`%~8w|OhUbCI4OclQyM{qlNh=20GAt)Bva|xn~{qs}6 zQeXJfR+LAhp83rrM}28$cHST{6-8c7-u5@sQuIULOukXM!hR%5`bug(dbB|m1_)S= z?+Tw7u#OsN{WOLjS<^G-Hu56DRV_`Sn{GI9_vT@GOc;Z1N23_u*Lm}JQi03(qix18 z8Qfxm#m3U!ZcyZ-tdl93T;_~+?jnID?}4coBMg>T!Wke9fhjoxfQu;-v&B_NLKjFMv)~r(a)6E7|r;@ zd;*^7u6TK-4nB{Cgt!D}s88pDXXUftZL1FMpUOkcS+d_)tfM4YLg`DhYkDpo7ajBt z;K%bx7n&kp{PR-|%m4EbEgO>b5Tjx5=G5dQKx@7pL#lap=WCZ{%vvT;>dSAQ=uu!1a_rAb zaXjx%S!sAt0}aOHYW%j>0SLW_k-ID~B6SsES-AmB@ak{_PG z@?V4)_^e1L#?#Ap%?D!&-JOn4*El}~U#V&E+?JN4_Rdg`^O=H~Mo->|>l@Er0?prZ zg6R!aUJWa=MX9`>D3OLfBvnN0lEj@^zFa&_1!OS#SVo}^kTjyz=p&pb`G^IT!mgwk zvf)xKFI?_V1=cdCk)C?)XA^q9or=WtiX0{Ex;1GdBlcn!Q<)q0HwVZJUWEB%vnRd0 z4mNqJHao>t!BDo$TLD_euu99c&1Awv)ePUoC#PHn1C0f6;QhRP>3=2YKj@2Hve6>A z&{YGr!gO`XBuP8C0b&zGn`mGbekc-9R!7%!JssJq$d;*|1ZQG`x8E(@rptxHEK9+A zRswEZ)e^^O)o;&e`ZjJ;tMUKK&B6IQ4SUOiYEQVqt>&{TL_8(Ys7)S&&+Ob~xqU`} z>&92MMer;qj5=lQXHn_Oz4yTe=wQs+e_^CWN)W%7jL%JDmS@={1CWDuXYx5uT$Bs5 z*Vwd!K1pN!Unv51ylMk8=>?cH(3^eWs%p>9ElAs#CF?nppsCx|!BCEDt)Z+$1stKX zC~g)8u1^jWo^5?G-6B&X^|?g0q6{veY)*jUT&BC^WnJ z2v>Yu2a26<_t)p>SiE>IB+=(nTpMa8sdM=Q9;>dv#p3_Z3jkXc0rRdkv?!YdtNL?g#K0J8W_PXGZ}8z6CJ-hksWsdC!v4 zzk&I~_M)Y!D$vszx#~?B_!Rp+i!vQh`lEDeLUtNGT4gmYp5~bZ@I@D@4|F+p{a)#` zU8;ZyecjsM{hpT>EL2?SvjHXKFc`YL6ms`{P_kBu`sE4+BH$jq$oVZ;pV_n2y6p(zf2a8*W@7;TwQfZhR9B^V!AA%yoC8 zlFyb`)opH!?m!ir&>_I7?_LvJASR_WACKU2+H*ZH?@m*TgU`7rawa zRs+i(n+M{(eGL_PZBf4}o@5I&!Y|mW5Z_Y#-I^&4?!~^v(V)jI6uqi?mBasoedi+6 z7`+}WZnRO7X8r+_bhccLh(o6*+05pH5nP8v{^td^Tl<+~bAl0=T&-azBTb)8)bJ*t z!F-Cg=$C^(^Zfs!l&Q0WR7_)H+Fbf@)7-V+i;K~OU#x2e*8iZE*zHZfnk2L_CXUM& z2z?c93JyC!3FvhVv*u?VHzVZK`bA;^>uzM4s<0c>&?pm53P0jGrxJPtT#_e91QQ0G z6UQ*fJ3PKzi#Y=R_;RZ`jWOo@!uPoiHL2kh6~%$sRVpS=r)nHod6RNfF|fe>5^TeB z7jA+iqcs|T4tY{MS)N%(iGpfAejd|3{=fJf>@S zL%P*ro3#S08&>aFaVX^uh9^b2Q=|FDDzJ7uJ+*Hh7&6Hq?rp?X1S72w&)Ol%5SpCHPsCfbb-#MoCK;TMYS1D|mz}pwjNm@<&p=?)meF zFU4-L3xND&S`0e1Jk~)f=vTrPsFZ{@- ztS-Vn;z2l*!D7I)+PM4JOs~$BO^U9wI-LV6S?2-gzccG6FdL0B1J|Ap@21rIuu*6c zbP8&fe;UF#!G*N0<&FZK=AXZRq*v@p{%?(l_=7@Q*YY8b{Cs-|jVja$rXnnT+b7z!03icAOZ>qy5S6%!h7@)F$GBo^vv9VLR4LIDkq>-g2ehI?{PAFXPc&fN>4Y zpz{}MV15G$hAOIAJVx_1l9pT5I-EAsm?LL2nRQ{b!50XGw<;XF9$S9whoXB z2VU4aoQpwJLG+IA(&$I<-$Ee>XBkN*$NVb?NAjkj!2k*Ke5UY3*{1Q$zR?_Jnk_2g z?`>sE!*SMuFYU8Z%}8X(K#+;27$$O9mUT(~==Q&*lfuazcCGp_fD;3kpI#6=KWf#q zl_(uS#QRDlrheS~U{MruwVuFdPO9fMV{YHFZ7vfc+i)4Lpw-~T5e0&JJCSc1$;UT` zsuOIr1Ir0n-mqX7;!6bvzEzRS(*cv*rC+mA=|X;|06h9qedirT=JNIdBp9`WnqC1< zsB`OS3BOg5G`_S)>%l#|=Q05C>kz$e!HsM%nSI6IXG`jKB2@fc)A;(-J=pMqK%fN+ z=0*--=B6P!EeDa5h6K*K4U_hcKk>)#F59mf4mHPwu@#i#KMKn;wXdgow-KeiiEuq> zL>bY;(Q;}GOSmT|C;w>a5k&pfl8K^D+YI)$aZVBQ>7ZHfMc{}tWaAHscA5#@+0W*+ z=R&Sg0xfbdD&ooE&}+ZXyN$Fv8BUD#x$7NSw~WjzS2UeEgNqBVulAO%755vElmdFq z0T-4VHZV0R7jSVI!tP*G8d#0&|v)XF4!Fy{( zN9bb2Lf*#*pCGHiy#XyGq<<_3GAvh##Rm43IX3_97@`SGyjkA*m8(F#}dX>l|=YPw_+q?OD%Ra=e zwSy&p%+7>xPDBdm;h3BYYwHoIANtB86qKm)@F`JD*)fyZO>NJtSVeK zL*K?xb`|yQVG1(Smlg|qb-B6gdMbq985oclHrx2H9(F`r@Xm5YXXsUn|HVQ54&1xp zay6>?O7YWXJX>il&$vS{)AG$o(ksNmms~ay(S`21Q8YSK!kMbpx?dHhz4bTyp8^Qj z^;;v|iiRIwEcM=tHl>Qc8aUoy+ae>)UaK( z={?y&7Ji7gz8cOiw|j4XNSgRUeo8@_=P`KpX`19vh>=s#=2(Kblnnk?2I-23GDR6BVM$joWRo!^NR9#!E&g1U)! zj`2<+*%c$S@Y=gZ125sB1rVZ`wWpRPDg)m~I$wO@N84rrj}5$#w24I2xsn)l+eui?T~IX@!R5R8spmfLp0%mtV87%oh&wJ1H~ro8iRhZDgU-I<(RC; znheGya@guKCLLy!k_rqCbZ|GgzTvrZLI=U9XtFXtCalp5l?uzR{3?3lQ;UfnlFWoZ zY8z)^pPX>q@b zQ5swM-7a-{cILRVV~Ai#(UU0>?i?E83m9(K= zQk%(79}nR-)218}_>L1FrpkRbbV!E>;P27 ze?Qre7bC8eGhuQQO>x=U>pErFo3Fr?GbtVhOLbbP9fuUCLOXtUKXa+VYC_79{w8&D zf^3XViT4p`8g!m;?XEB09Bh<5Y<|)fs7)IzYfXdn|ClOTpB;(LAxurxE|oute0+0$ zw0drlnwIv_#3w^4G=`gBbT}Fb2l3itQ=0A+mZtr@3v)(7OR)pP=TMqwIXJKl06h7| zvS`!LenL>HVCw0L8qUBK5zB0LgjukWr;wsrHk@WLWAegxDXWt_owzp^Bz(x!bcFlyf3*)biSJ(EMwS@FM=R4obC^V{Bd>(>X+CcV)B@vl4h zHBX_zt+U&<-tuv8jB@!}Fj0jTBlt%37s#&h9N$^`)p~amH{jZzi(jnW6z$%+M*(Tt z)P{TfeOBvxGsmvq95xIhnMbc9>P-d-0oj*W+zmf(orRaTjjFhYxWs!QoDWQ+DK?VR zKjkl2A5P;bJM~idBbuLJYKaK+0O{{oZ~R-DiMdyN?nL&26`s4v3(yCyDU0@lnMc>V z90@q`-7p^jGRd*bG#{CO>>QZVyJb)2jrCtkgZW+91RWd@yE?K}na-~y_2f3TM;W`t zj_TS=8F*d`EHqxu-oF*SgOtd5MTNED@Pk15spXquy{eEJKtzKTz(3wyKL`8KkvL;^ zZZL*t*UyevTc%5^B98HCj1PEso{DAtG;#p~FM7ZMP{egS7t?+ufk?2l%Ktc6gk`mC zDp0;qzd;J$TgLKvP72qwiqy64pD{0Sy`%lUU=0$u zpJj&)g2J0zR7N*N0#~h0QzY7^Wti}S%`KgpFP<-Eei!y7|Ccl%&G2>0MFdo&3Xdyd zz%)kIjMtUBU)bm3vg=nywzo?p9{-j(nbo!LJkdLquUatQuH@;_D9O_)8&6BkAK(7H z?eat8r){ebW{P1;Qu@W7=>uFpawr`E+^o;Od^WEFMLOrQRTlpPw?l{Iwe2zig)I%L z{5%c1lz@F}VtDv7_`*HJed&b5zInqOEhIEGO=v)EuJ#D%S4UfTa~|7y`qi%~ifcS1 z-r)9D>y#K25bPXZL0ID65BckW1a$=y3oTc;*+;j6kz&_)(_&sS3>0irtW=(nCsU-F z|AklCpz9pB(BNpgQ`wHp(;e6I%Q zy>7_*frN*jU2ov~;QX5tdlp*?Whpc1K2x#y266-Mz>r{4e2GG;mayw{FPzM-_a;w6 z3cb%cusrP-HsV|*5j=3Zk+KOn`Ti$CHK!kIU_vY16mtz1`%Q5JYv;P3%ocBhyI=y^ z@%5!&)Gb=52gbV02Ib3$jyZxc1rDlp`3jhbiODD%bEN<6Y=#0ZUhG& zKODe+R>XY==jG=9%sP}Ya^9@sJ|d6wR8CIMXOSSTupSmEZMzrQZ`|SZLq6QM5tH1} ziNFMShXsaHNx-4$$rG5Dn;!h?GcF2^g+-1!54Mks$(O*;m`ca0c49>w)GDXF6LigA zT9Knw&gH7#eU_f=X?aUJ%gAZ7!xa3C@VV-E(1Oz`iq%<5(JTKWdCcSo_li4swQl0S~#K&L;43l zS{A+xSz=7Eq;?R?bs+&#;-t@RX^rMyO2D1mvZG-zYhNCrxeYz zbe|>8;hDujl|Up->GV}q*DC|6sFo=xPFq7}AtAU|}azbTBQkNiP^^yap_qzkeb9({`nx(5fQ;S_ybD5^V+6_De*a&C)R(z%A z$}J}o{hk7RlwizAK@BU_l6B6Uq0*(KOIjQA zhU_zbKJb2<)Hj@H8at_obQ9qjmRWmBz~I>qkPeYQa~;1hp{fvb^FiJvH{EVPG+Vw@ z)zP@3O>xy(7)A6Jfz4%V2VDaTA{vGstugja?8nD$=}5SDG=S5l8QyOg8hf-$f|V*N z{E_A1*Vtvo3=9lQiVZMzRi|i&F-i2m&ma;O?&U+a=N4MT+4iON-Y+eRBwh$D!{x*l z@e7>>{R`kXXZI1?%V!D5z2^xg4VaVs*F8WZ`E7{{*f~Ge`kR^j~48N@? z@$bg_9>;fZWKf*Xhuqk=HJTg?FB(e-axiTt%wSZ8R=_r$k0 zQeJRU50}>u`m(F+gQE>@PwHJ{813!!{(eF{VG4DY%R`qW!k*ygXbsBXH zu`IEwO%F1DyY=+n8C+CnYkX0fBII@&mcGK3h;q)imZK!?o-_1KvtQun`%mjScuW+i zC?(IIVpDA{XGz&M`e07zJlFqWov7NicV6U34;}&XbLC?l@CXheF?@rgI?fk@ts|W= zq9bW%J2M^|{HQ9ydOPsITvl^(1mmPmwbG#|cA;e2Fkn#Fu4g_}i4n5v^!+;Ih6%}d zfvg(ol}#djflo?_l3MISO}*1F{zQGXNa5Ej@~F|jEOLr*>*5fJ?+})&LfzSy^**qeXc{mST3-m0nd+$+LXg(@ zI4lYbhgwzE3<$9c@+g@cCS^RrcQ4yxF>y4OpVG*XIqjI+$jWS1*v{Yrp$O(NZrt4u zw*lv)woCz!l&Lj_1DUVV+m*PD5WXo7c<)g^$xoFxC4OEprjay?`hs=*JQDs(AQf|* z9R6)Rc}frQ-Y~ee?R>Gn_N?kqD|TpWJV1sF|1Ufg`W7p}{pflT}+4cJGvx z8l&?QJ%U}P%QUovAOn4UIBdxr7HiT(juVqRTFoxP11B$4X&-0ij;}0!TIkkaYK}nG ziT5TKl`@uZ7B_Wbn4h36$b1&vNvHphIHDa_h6Z>9eD}O%sxRl?uL$ax~~ZF-k@9X+5Ao zfHsHrl>RB0m|h;SgvbIb6iL>>OH{F_?ZR=+H&Hd5U!bfqp`j$C#9*r?p6`j?xeL>N zthq20?V~5!>gjMmBoDn6G}@?r%xu?lo8kW4-!F_^(R1m>@5`v?$!~2C=SvN$e$wB) z_;}2)z+zDLF-pnEIeXMFC~qF-^jU(#!2D?za$W+uHYz6>|6Cp&b3M%_X?>$K#k4r zvqcL*ax7ny*&8AD?|dxga^|l$>sI6gMsO>KSk#n=O8Cdec|nCzwWZ!Nks2G0Qz#~A z86FG>@cY6$eX0U|8A5|68v_7NvOoE`_I&~dmYIp{TJc#dax~Smg2J;0ti+Y%<@>Rj z{;8YbV5oQr1f3GM^j{ZS2M1iMSo1_>%=GnT8b?gQZ_RFI+tkVl#KFBWp1U#k&Eyp=g6MA~jvN^DX z=zwKmoNzi!MV8}MI;^0eq1}MX>hK-k8?Ui^js9(;{&D<`8xS^}hE(5iT|AC)QL|OJJ`khts?{yR)^k18C#fKfa7OyCgRZN1br=)&q6Qj75AHRCM%0 zd{1~zl+3ir{mbQC;YQ7(Eoa{E&TAa&&*BI6?F^#i;^Va=-8O09$gCPhc|3?=#Z|ll zv3`9Rw0rLwlU-}gN!>9*u$b|X9z~FjG~`hd^sS*Gm8PEGlZH{q!!B?2>>eI{FA@*e z;%(w~hVRXJrHQRDQHlN&MkcPIJiSqSZ!!S}F2u9S?S%W+dp9Qb5^TS;Kz*o4D*7h= zNlZ1vQZ+GOII3qz+ebhgT5qzXrjPduN#1JSDI;J%-=*MvemEArXSqi|Y8Aiyq@ax^ zrzU^YvhgyX8x+j!+`+#?HEyF?+93xw9&jhlTIqsQm+*w3c^$a#=Ih&b|I3(SotiYk zc|Wo(*{C zZREYTc2H}hOP;GFG}85?-k2C{4LkBs-D zJmwPKmRqP!OV4YN&S+gj`f$f}9~pk+ICSN4UHoJ%o~};(jza7r7~woPT<36CGe!6H z;-kC440Z=R-Kl>tr-l)6qIU1zsKuVo{hxF6h;S=axyuzaL{>I{_P$`6c#EFG?O@t( zGIKlzMKX+*6gp>V&1%$zWIzD^(Q=M!^iSY8l!4+H)I2^-Z!;V*N5HVC^(~Y zgsd+6bkm8Bv!ZA5sM4erR)}!EsJ>M8>bFg|w8jWO?Y^V8nj^ZmdMq2OT3^?mzK2gW zQSl<(en&O_`4tY+qFHbxURyV+%IE#*p5CDPW{!6}R=VO-MuqZ)u$-W-euGtenK*XSCbFJZ-rgPP|5yw0*Jee^807r*aHOzS!kjCH90bF4L-&e>$>s3Wzs7D z_-r}jTS-kRuln0LJJ{*^Q-6@;daO0$!Vr61Bzg8#1I$AAPF z+z(!v#^0wrvn{wM?%2Z?Eq;2x#?s=G)VjX;sm?}F{2z}6l1`EL#qOL!2L1kBs7>66 z=ru?>fPs9eOTYgd!MZhwg-PS7b$SBYjNXIWkv3`OZiM?}Z|(ni0UnABjaNE?EluNk zjH>rrG%Fzo-Dw$rYv5#`_#m%3&IA|V_FAGW72wKXy}&AWI%7pm)+kbJ(dj-hTny^d z*%1&ZVL-U5$X#1vHUuO5H`RPL0ERE{;oiMryGIvXXy1?pmf;VayobioKQlOb`2Q(k zaT~&DOx=42MdOx34n8L2hVm&l+U%4~=2((YqAuUGCzf!ev_*$3`ph8Q<@Mm0t3egM zTGux%(~5st27{HfPTjs&O|%lrAWMg|SU@@fnp1*?aPPHvPP|9?G;?S=`^_ji%X>KT zm2?!_uN-bk6i=QV(fkz1#8G(RJtjv5GSbMpvP0pp^_$b+wQO)MGv1$ zWP!YoUdhtMX?8C;!PR|s=$+z-y%Fr^VQhT67mWKSxP}ie$q=yCkQy)NX6DC!X4}a6 zx+>0GD$8ji7oSHWH4&>b;hPWaBm_|OW4^WD?T-P{<`v}C->=L(?zi99H*mU}#eOaS zdUJrxDhQjSsI_hQBG_`J=yL-1Cf2P=c5gmuL7#~!C-F=+j-rt_`2tOX45H_3nYAh0 z(pL84J(_CSL@RCBpIz+9OWePaXOVaPxRtrc{X2wR-l|qaYvon)V|p0(I~32??kgcD|24oQt?@G zr;xLu7Q9S?mi-V(Sp2+$f#LP_#$ICE)1z{SJIyqpwN)$#hu&&-r+!@S%ATUT1_R=B2-J;ZgqTwm=?;>|rImfcp8{z^A_K;yI(N;K%O=yZnBJojxcYJz{@ zX6Mo>s`)Gdrv8@-4+%NaUM;{S55h-h)2ow)W^>abc$w^?X_c6v$TlIf4Jah(89H3d$E#Awt-k*Is90L-{Tua0Rk=?J0 zKm+`*6@umswEn* zj1R~yy##uSv?w&sWV{fX+AY85&!d(-e_G^^TMImU1T&-eR4RQgu`Ch>g?8w`zVc(e zcs_0~aMT&rzM?X_N2rqbg+Jt9sNI;oz;7KqG@4fAnFwqFNt0(}Z9PU2aX^!pyI^@L zlEcf(3((bvhuqn!?HEj=dpkQ!6Cr$2+t`vI8w*PcDNu;-7;hA8WMovXDc21fu_F3j zR$X5^xq9`;5z-GA^|lm9W7jG#cP~{UE8OBEyUa3nu#7D#of+sAzgB6zY(VhTy0D}e zRwcO=DdGgLrS5{x>uxy+)PL{13rRK6oLP1Q0 zIm5UruDc1`!~?24xp*q zTHp!^f4$KZc@vh)o|H+@;3t?wS^rxh zs-EST9VV1yg(z24dMK{aZ@UKRmY{L%PLB+oVri#wi}^*y#d)%m>5kl9VWM}S>ko0| z!CuT|dME!-&C)1wvb`lnmnd0OPV4G&>{wo=&N)Fgd63fRxx6K>@?MoT&o3ZJ6^{wV zOo`32*u3^QX8(~e;R)=2RXm+>M~YVmPJ#v#d-enG9`*pVemakjsA` zdD-%CNp)G~e`$Dy@IOYfYjKzL1w2Wx659Jhx)~Gg1bXOKqWr_)isk{W@HnE~B_io0O^$H6L!d8#RVU;Bug1kvM}AAQ$N9i&JKvnTQs$G?bkLGgRBJFedqy^2{4rh#FSJ8$)g{kb z0!PS{E{|I)KZXh!7fQ9dB1>uheGxHRQv@PQWm8kFa6%rL4yHH{MhQCZZmG0hl{5)^ zxn#H%NayJo4-ZV-Uf%eB&5Bb&LwkDUJGg%IZ2$Uts{Z2s225jU5Ke#ZTs7DYM+j2% zNBDKi%=)KUUr>qsQd1Uf55yJ?!;P=mnQ~q~G^X@jS5YS}H{ZaREYt68_B^S-X!V}C z@4$4?vAg9q+K$hgcN^r;b3Nl%xAp~RZV^u>T@0j4u+@{O$!-6w9MeI`lufZ=UGz>_ z3%sao28#3H@XKf4CWF<3gUi?1%-Ogfggn-{K^vzBGWE6~$SaE1^|xb#9&2PvL$|>Z za`E3E>`6DmOx4l=nR$oV)fd{Jd{_dt> z<=UoUdveOrd?G1*u4LjbU)nflhqR5o$6i$P{Za4LZc6JfUw41lRLgx-B-V49;N0Sa?pT z$059Frr{Gd)n%%G&tKOa6_ocFY}E3qx4hizB2=TZ{cTOW{n}~Z4uiMW`zz=p<0K7 z((_W{{;!n3^moYpq4ERS&Sa_UPrRjGQg?AUKC=p8CIbVJh&bueA_IeX5P&u!ufCI^ zf7nRdDMiliP%hgTUSVL1A9E*JN5#dx6bwD_{eLvQWk6Ja*Zr+DNU5}>AT1#c1N`U) z0qJ%K0qGo4TDlvC28p4&Lpp{KP-^IqX6Ss5_x1eW@q(I}bIy0~wb%ZvdM_Z#rT>iG zZK8^-*sAzXo3{Xz)bV6eB2+GvoSO1qmi=ap-J&3XugDg(^s)&Bl3fUcpL<^(Zi%Rg zM_-kyod9#~$bT^oSCe#N$Ukbx-{4q6AbS^P&^O($^xMN!9DeK>&?gt07rkvXI`BOo zr)BD3r6Y4=Fc#TcX>>ko^R?X*H7tgDt!A*X#(Uo0=0X@C?|hz0=*O-2YvpVc0obmQ z{ha>c>~P420YU=NO{?aA2f)6g9UKpKU(Qt;47T#^3;Ov4?wI`U(Ny!z9Nr@@o5gt} zU^23r|LzMIuyMFY)dZ_c7xS6wwwhyW0!px$PjE?l$sex^?d|u5SdxUnbpPVT12Cy+ z$KB{GCMI@4S(GqTdoxlQF%jUmW_$QSyIkiau#de;?hrVT~l6O zi#>MJ(p;x@Ni(kc`|V2M;^CdPE*i(ygq~QKyHy1zC3u<8pa8fQWjJqm?>C!3zzN9dG-H(5Fgc4L-vnPrv8K&5aS6-1TPPKQM{)EUrAN+IK$SUHh#n*Vi*vd@|O? z_gtg%GE%aA4-ET;3kK8DGYYfGo$XE@o|Q_g3li0}WbJAnDt8z^f|_qNO{37GTzpcd zg;w5H_nt>g1M*mu8f|dyI=pW`BbGap)YrZ$)+rS5&8Cn(9F_-!=rwk4uyFx;c z*OREv0hnfEHJ%>G^Oc;A0(U-))kV<=jRc5#Utjn?7_b{Q6C#ktQ)Bk_5`RQSEj$o9;R5UN(`2FEG| z^rhZH_WzU=Ctl{!m`0g7=Bg$z8Ujle$KLZIo`0w0JU=f25c7_Rsi~LkT(mJFx^y40 zr0K#nWW+L9oF9zsCGwspNn(YUfPCQe(XXS>vrE{G+tYwLiX!E`!Gyq3Ya|>2VQK?* zgH1ituG;UY0CYx#Vngo(!4iDF(}`5XqeHr!FKGBR{?TGT{US9w41#=v=#B>VC+=k; zg{rLxJpA?|K_}g)|9FFj{>ymh1i0#WY?Z$!O_5RMRZG3L_RRqufc&=Bb%zxeOD&^Ku$wblwV(5rPNZ}aH*Y4UV|a6IXja6ev-9)E4g7;`dP^*Ps8xV4A#^;pHWP9}yb?IWfO}Eo0if^A&63Z$paW@J;@;UXn8SEXGyZlKh|J~-n zNdUTjhIw_oGgKq>^_)XubwiSF~g9}0QoBqkMHsFxd~yKXa|`js=z9&Wlv@Ymn_EV~ zasxs>tIy;E;-G9NQHj-x);0Wc@>bHY7aMu@6%o7CQft+C=lsI014e$UIKH`QYwx#J zy$9J}_U5~d{5o}Vr2rNJ$SJ7k&O}{{hc(CZZz6xp{&ij8h@JjR8BRN@S;+sJ9rK+8 z1dB*Nh)}3yB2JQa%R?z7ny(+3=6jg6N9-vRrXz3VW8NTZ{2!IG?R!`{m9B)%o`8Jb{s#jn{;GkBuwfQXosKp60o2_O}>5}a%Rg1^xU1^7U9&S zEGySGiUxfu+e~0)2HY#2JHWPb&i$4N0E=1*r$MV|^Q70SG@>ktL$h(mFIkNCE?PdQ zd>NaRuS4dR?UeeSW~0RatVCD1F(GfwO!yFgvB_blA2=>8<0lrtJfVT5pUr=T z@TMsn`U0wVAn-tV6EG@34ppkw#vLFpr1}cR#+2(k_cZ>6Engli^iO1qK!B`wNMGiP zq;@QuOo{oljyEGdvY~9T^^7ccK+~P0+_4x?Zlrh513( zx^Rt%yg|m|9RVl))2GZ_={b8-)AE3-5&dn{o+jS4xbW}_cCI+ew~v9X_cZ~fc@X6=(s>00c&9uub5m7=n0RlVM+xzNktD?1Z3zf z&(+o~1SP6*_m{7G2=iP2_SbEy9fQ5=Hxce_eR-&N>0~r==mCjYS7M7skj?PHgMTqp zty#0YJtR951d@dsg$f6s!y>*Eag_<`EVH}Glrb-9$e4j`-{%{U=|>K`#Kh8oZO#P8 z)2&I~8>n_@(-FM{aE$*%)+id$h-wTo30Cemm>RCtE_NTwGTYd2W-Gft5AVoJSY>N3 zcj4|J0LCyc+EPgS8OND2Y>eJY((Qd3HK@y&--p1--rW7>d}B zdNq+%R;9f)@?PgGAm;%>!frUU^LWa$bULi&xMh*b<92|R$#2rT+x{}akcV$JSHJva zs2DL~xPI}U|DU-CtAKFp##53w9ZH@p_zp*^omLW~a^_*Wa(Rq5^T6}c`l#!Qx)X9N z`nBbj!tcrB$z-kq(LJ>KjDPgI6~%cpE|j)_6KJ&*{al+JD<^;%6S)z2B4OoSVlhi( zYV2u1&YjRv>#;;9@|BjeK$}E ze7iu8gF?b-tV|}$Yh_uj`*)TV%r@}5!-Eqpie$gLJh0q5OFr;9MK}I^ih}y^U|4U4 zDn(xaeDA77L{6dzzspWh>r0+l{b*i=e|J$V=#0=~*^M-yBoeEj!@RuaNMk zlkz)3@6=uW4#hUAI`bQ6znfJ5R=^HE^sa<1ufUtIMoLXXeEp9))! z-11uM!d!A@*jg5#ICSsKie%fC-62Jtv80~T7tfuEU4Q`e&ifYlNqnqN@J^$6ti(xj zm2dKvQp!n+M`xJD=pYtIX34&70#5M7-tnk?5u3*WrFLw%xnYVK*agmSNGy%eRKSAC zketdGf83nc_b@ry%evNG9?ut474+F91R9K?Xu7!PB+oU@aqGMW`zw~_kUoK24Db)N zLK=pgC)k06*;YWdh(-b}){m=;8GAl8-ao8IPf2zD8sCx_tVe!cbAu2}hBYW=@6F6E zi=3#GijvwoYBu!~Erm1`ob4v($l251KIz~nK&=W(c_=kCTH#U++i$%p(18p9fjWI@ z0&Es3-d>x;zc_Uyzg~N-rCE1 zuHF~)h5zgsfORT>R*9#6YIli?3O@OjzjV$9pejbfpEj(ne_4quW!P4>{AKmKnD-AF zvF zQ$T&rSYp&Dtp+1G z0WZ3Z@lr!1LwLHlKOcP`ePwmrQ&NfTm4*1!X(MUC#*L>RkgBoV2OtpfVraxCyjM=$ zS1w~bxE*@(-=fa-&u3{>u-%IytVZW-_x6u>V!G}O9*-QJNH;JEP6nDfvx)cT;1L@_Z!$1or6gZ&9~pZv6iVIslQX)08sgSpQj@|9$dA9q>$81K zfNKp0x;xRKU*Vo9QTCfM-|>TXh~CE(3rb*lG~9$cKDNVGp++8w2ik z;Lo7;^#T1?OZ#emopl5j8JJE0LroD7dB-)Bp`=I6BrL>`l!SMsk+`R#>+YF9GRR$@C?vRNpxP0neoPswK}%+Hg=95Q6(fAY)8f?Q|VjDZPIol4jrVrO5!0Bj*vG zJOB*Je5P0h=#uGCAAC)5&EEB1B}HzrM3(?(OX2^GG9!VB4CRl8Aq8SkB8Er61A z28d*A_f!6ls7H_6%U{6PHCK;<$!qG)@rgg39Ewl8o%`PxdNCzhk{f%x&4$n-YPb{WWdl(4Lt+u>tDAR zOI-#*$2Vx5u{8tzLApwxU^RXZUcfWvxBoSvn)m~*ju8Y8$mV7`M+MCNN<^{@*#P-B z_-f?EVq&D)GXw!vZ`>(xpfzRqTu#92ypO4kJ!VvVR(Jg3BL(ajPl)s~2%Eqd7!&qn zZ5j!d1>v8lFZ4r38^4-4ntqGDuOdJKNYrqE%;JK4-&AYa$4J6%ELn`#`ODO*&1pGi zDZP>k#too?0B6k4mhE(=oYfF2IC6I*_Uw&qIsIG ztdH$7R`|y!i%Y|Ps~#|@1X7V=g1JmTpP*rkF`!AJU^7rOE!cM5KFl49=z65MkJHFY%4}{c)?0=6 z@nNghG`gc}qp3?%VqlqtFH*H8YRbdQ@iC1Jw^T~`tc@q3yUspl@m=@lB`tu*diUxs z2E`$JI8ny&Z%m@+OlIX4li#gXdN!0nrH*xAlrThW2kK941@#aML!9tl`8|{`Jw#Wz znC}V7=$);KBG#wEsLkCiQ`}tk(=xJ)77tP4ipV1eN%eFEw|%hd)x%t!|DP8iZ{EPd z%sO0>^y^}4bYx{q=xAkgM7TR9U=vU3)d`%&l0?ueXx8%5<4E0~6n$pkA0PvRUUOE8 zoRfj?MJ4rG0ZL&B9&X<=geEW)wH~#t^rY(5_1i!^zOnB*bSDgK>N*VDRaO@6ONn@; z_jHp@F*PL^H8Az6x*6qzeUn0%)W};VT*+1#e^|};vKGFDz3#W-Karv%wWeH@)%Nay ziPDJ@i7I~Lwc>fW$Q+UI7EXwzt&;-zdqT&+B_tHWT^YbTu&T5XWfx2vqc81b`<|`( zLl28vcts9E-`RE;2`uKQuG9npEZ4ZlGn^p5oaW^L0w4AWUKNFzBy+)^I)NAa0+ZQL zSsl&n4Crs01_i=Rh++lct5EzU;uf1`aH-|0`wT>T(mf-tuV58Pgkl}+9avr z>sY~s0%VgmO@aU;=H|xahSX=R%RdHjw~Sb8g&V;|R?aN_t~-vUAk>Te<1;Y@j86oe zF7gjgI6m-=-%|xiB>0q|ZaMK=GyAp;d=9}Y%F5<;AHg zzhb#npv5do6-l=9CZbi~ySXrp*)c6rw>_##J zzRrc*Fl@aKh3p>!9YcC@V`)OA)yICGv-eynFx@{$8Yk(lvNidIBc6uB^z`&(aROv% zD+aE73XhRN4y`FUw=Gv2Vb3*m8AwKw*m;t)37hC+IN56~{Gd1GmD~A13gV1)9;p9u z@DeHD;S(}QgMepyEce&+Zknz*Dt#vd75Bic+YHs$hSK6&fT#oJz}$aob0ys}twt_isr{ugi@74rrJ+21!|> z|LvgTE-Bp1gb^Tb_QePLysyrn9vzW0aKTX(r>MN@iC_%c(HDS>Hku{I%&CYGM5j(v z0Hfm^WfhhbQZZQiJa66BeEPz~+}b+)Ay!nee3sGPEpDWwsdc0#1l_B=+?A;nfVQ9A z7e9X=MW>(O9%*R;|*-*tmW{ii8biL*1<<)J8``tV}&KE+$ zxiTg_#$#s+g{5fewmeiid{Usl^j)cR-e#4THGU)#VpCE&Pa#oAq$@gEx=Y?kg2a5n z5qDI6UUFE$^Kt&iDD?O;xRTMQZ;jCI{T?lCcABY|JO0*9lFY#05uA>mZoY5&8|crW zaSVNQ7$^Ds0XtfHwIQ}*Fc@P630Tq4wM^IyKGza6Ko&JM-Y_@OZ;Ppx{3q63^SA+f z|GQa21DR2N*-(mWTCURg*ga#hmF1*vT*9z>WTKi-I$M>``;ud^NDzED5lsyOT>2%7 zAn~u4<2(o&+xH}qpI&Xv-sEAh{HH4g-Kt>cq)%>BGuMl0GDC$P>&)|?@n@}Sw--B5 zW#5aLOvvk=2C?bVH7fd_aWE{1A>NL+S1|swAQ#VrD`~D|M5;+c7FAcY%%h7@GVy{+Wu!F zH*4n6K<#oF51UZ;lE^tBo@IRfRIIEq$!FPuZZsDJ12xuH|H31`n z;g^kH5yM-l#v@jbcNZYXCsf_%Z5}xi<%>n^iuEvJT5<^oBEfDd-YppSa0L z#9fOOlH7?q-SJqtSfPBjLdhYz!sb6 zeR2xfA;`t2=PzEo@Hy|J*#?M0_7qm{r}fWjH#x=bbPmM!*(=+(@xHD!$JaV~H!x?X zsLO}n8#nmt>x>tJiHR)M@HyfNt!0HNKTzW98tJ>r$`7nUTEnx{;|&lCgk$=0y2)C& z5isS!!W}IN8KC@@wXJ2KBR|(WB-krK_alre!tPsP4SC6IMrDD}kK#D7AclSBoh#!L zh0IEaI7KBTu#@MH)>>EA^AG8d8mK9kTfXW3g&Xj|1Tb*)asoEb0?b?F`Kj zRpr-|+X(CP|I!1*?s7g6RpIdR%GL;=4oP(ZFzK|oMxWx&mU|3#FY~!6SnM{=jP`ry zc`Gk6E#^}wK8_6Hgz)qd6NOmrUB8t{naR$|U*4OHpclaA{UmHZh-%GPUhK!2gQ)!> zuL%j6;F8l|wrVG>1z%p1F1UG_g z_nSklR0;H~^Xli4SCsgP#KE|&?5Av^+dqE-DXd2LRKmd=d=_gI?*#&gO!4wZYNHJ7 zF0(qq`oeNHw+-yKkOE8H;Jd3jvpz3?xM3VaE!6u@k6$L%asIp4HauOQA^p3!nSJyX z-O?s7kM`bXSSIK&D3M8j3wkC7o4o^po zFE-ZNFSp7%>|+M7?Uw$CNxs1r+@P+x`<+q#jyE+>#K0&Iu!xl(L+*?JGSm$_00_ zUI0rYsG0l~a?ka@S)o>kHa$&>2)XVmh+UMb31A2p%>i?j^d+>r$th%@i%y{=|@KKt?i55 z+HS1y9f($6vn8#zly*z9{a@W$*Msi`=@g5+O>RHGH`>N?r6`W-S%YBQvxUk+(G|{K z>$U9VT}bRcEU=u)SdzETT&+ar{%iW1JS|ka=i(>Wy+eDlbrtE<6tGOxZ>@Q@O^aFn zM?!{P!$s};9pVF<=ad~=??&Ew+EEn*6P$>cXE79{3HJ)HJ=0erSl@r zcr6W#;7nc{u#nsQaQm^Zcn_P2_dBO@nfRSeYgsnGqo91C90W)0yxzcYjp8=`h86g2 zxKyE*eUJbJWc$aZXY^X&>F8eZnyyrP?gTxF395BFyz3C+AW~% zvHoTjl4JFK2erTN2C3lnPdaKpa~gRi$^k={aXv%8o2{?QjZ`qcj${i-gvTd%i%>qT zYa*&G`MFoUFx5!@&lf1g#fDNj7UbR&Vv*TQISWKLw&Z22%rT*FJ&0PkVywNXQerrP zP$7v7h9$>7JRl0*qxJ(CU;^v+Mj)wI9w$6%%{DB1X&t-R9**nrIvq}uUVIaf)nsJJ z4#&?vDph_Oiapz=xitfr7bB=1zCp?T8wZPbv^h`v`$8+;N1#te=E2a<%S)6@cFVoC zCP)gu^_@o+r}B_9lsP#3b%@qCU-fCF&@X73nnt~}rk3t0{@3)!>otG}=&*6|rG^$H z)85Mi-f?wC^R(gc(lcVd{mAB?E0_0O08KtyYvZy1m95S5a=r$MlExGU6+L4^^Q~*A zS_TQ$@Fat?LVxfLcp3i@7yilL#xl42=M4Nt5`8nJ2_JVZs z>nhZeJLN>QYSp$9zUiws@2x)UCYG=aNRqM2u?(sgMZO&*kou2TFIOXamvc11tV<1Q zk+c;)(R%Tzp>qPPCfW~twp*$G7xQUZS&}R=4v?v-*aq1$zVXsCpH#f^(T0n%$B7qG z0(*A`=kt6p-T!#78|U%^%sxo#;4f7NXtzZ(p-VE?8%5S8&|_l3nNZ;1v_iBzwNkz! zes&l;lGOj!8URo5Y|0Q@tV4(_!kN$v_#M_okNpHV+pdZ0^{Kc9rtFbtH-17ueKtS_ z$5yuiN7k+m4_+Z#%d4KRK8Rn{wLefDn|}5R<1VxP@%fc+!`x09K{EX>RT z!b`1d*}+_7(}(rT(lbcNS@(1MhxKTmGk|e&cXY?Er{_4XrE@wmYBD}C<34rds;j5} zSrCxU{feXvUAU4Jo$h~glf=?k^$kQTtEy zV8TUZEU{va2xL(CQ-dUe3ZJ9N;fscIQ*@2oMir#(wFv1ib9D4P!!EQQi7&yYE3$D- zu4Hb)#qbT6Vt%L<@PyLgAA+-^mt7xj-p+6cU{2SEq=K| zv*9LwBCDN3GF*$xvfMy{1{0M0bXyJ@eW@{N-Cw~$vopuJ+?$QK7RH2nqFAu&bUa@8 zoS=%sx9t}9T!p{&zb2G1)4UhUxqCl9p)0pKR^!TNR-@56(2oROazPlr)4`DDxwbc@ zo*`sn5cySs==LX!f4S7U@!!{*)zj!MaPLWgkRIMa4+<; zS=*hU(ug~Ta=8TwaPvi<`FM>+GW0#~q^VF~vh6Szg;j`kxq(G9US<>l4-tjd86I43 zQH%#IuX531OUtEt@(j1gbrR@tBJM2{Z^p=#b%XG=+0c3oJ^W^ceB;Z-#qIq3kLVt( z=L4onB`RMV7Jzk%T6;gJ`yzSH-t<axGP$6p4H8Orn zg@5Xk!#$*ZYvqeK2iDQTysc9S(```|bcRZaaR z1U`?!7*O;XV2SE`rcTM@a%(?Q%TSIo^+5Ymcb-gX_4kb0DZq=IIVKR?N=i&O5KvPm z!b6|ekEFRi;;zMo6JSY^hEJL3Ssp)JIXyKUZ;kpRiGl5wu^ErkGM%mnnwzPsT5Dv= z0B*l#0%-gsIrfYJ6zdccJ%>*^yY7usPAOU^Z5on0qXygyHx&EYA4{LCE!@(q_Syw;=ANRkOBL=ksPI#7P2Se|KZR#z#jQ?*R~0eg)xSb|6g&tUxwBs7Iq`dASo zmO_+38^s){7%Q}{FQRCa3=JzYbS|w6C=dO(|4OmR4|+_``qx8mbM{+U?MP3-P%6J1mGE;0l?a=12Lp>ub{iV1wCPd#hoXL@Bo>=74sS8miM=U z4oHBSUeb6WeUu~+l+lw82)x#PUJNN!en^g^r%T^|oGS*Ew9IU$UsJUejCpxHv>ygq zv>5wBwe?dd)L5n&N_k~6*hfEV)!4AfO|p;g65Oi3V9joP51+QdF=si;s&`JcivX`J zDP%7eM{1PT$rkMdxOMH^iM2+wlbzqGoQG9LtZB5pHPMRxHuVm=)5cd;+$f`$P{N{@ zAQ<$@NT!Onl~*YN_f1f-aI>EUB)qNj#?AhE|4s8uez$FM9u5Q-EINB;vdwnuFCO z{b02pA`4=1K|z2U1pa#?*TtV~rl_|^W;-~)m#(J_t@D5KOVQD06W5z(zzvharxa5b zITx~<=g6m}#YKtY_w4bI>v5~0=8$o+J{1hh5tPqhxK7T&Em@r-!U5PQqBtAqeE}J`lMDJShI`-zVYccbabhy}_qf_=9T^q61GZRA_XE>K z@0Gqch-=x$#hizC{?|3Jj!!`ZC!4P^Z*FytO#24#4Bh{*d2ZQO(&84381WRb<4l_c zCIk2fTrJ5;r4k!Yw=zL7&DRI!{1Z5k=T5}~1)l#H#U^@|nZp_-Z;A6a=u zZcCN-F{0KH{rDDdAM*A1VaaDS)zcgy1}X()CXTHHoz8@o7D$5m_v4%7smP+Zcbb}1 z+UQFj$4%D@0$n{T9p2=X=Uj7+e?~c0A877rcRCNY(A4FdME2%juh(#;#uvP1HOqEh zN@Beg|B|Jg>DH9;ot14mj4NuXhd$7~?SX3C?_ThyG`$lIy*NwJ=yM{)58T{S%4O{- zz=*E9RhBk}KB?qOh?v7unD|)l`dk0&@PEevt8m%Rq<4{WF{gWK57>*1UpK}b{F$t= zk|?U!mtD0WQi=p&O;8i#Q(S%3#5zm zwB&wgERWGaJz_8;^Ebkn293_GkFWJf+D+bkTpy&NM}k#qc;rYXjLhY=yR1x#`1)Ip zMJ5B6&B_Gb-5eH}oBm6%_Wgq5XoUGjT>u zBw3E;53o3b_?d0;z#4WeHb#GU=`=Whv>Bs>^CfLJ1nMoVa25A z`b_ofBoY?N>-miB#au~R8`>hqC^3vWz7K}upO*id_eUy67#yBMdTs9vB03v-UB`#e z1$%1hIJ|7VjIzDIl!yKo1KK`2MdzIds z6Ey{D$jv?ir<2tUpPNfgu(76lU)gS%W_o z{)zLel8aA0x=MC_?K-zE_7^TK%Az#mI$qScurrrtqpu~@w9wG}T4deaHoE7_JXX^p z72rw-DUn}#&vug7s*v(xh(`C>$BP)15XL-aSb5HU!lXR%W{twi$1)-@SD5xum7_PX z5r$<7k8Jy%JpB`YAm)Mi0a+Ai}pLK_u}svGzl7YG_;o0ye=m-ug< zYH1&HBu!expgoVN)!;rSgV435%BGMjsl1xI%6MZFC8GPa-#*ZoC_|SubeNFE*S_mU zR_vxG)(LnbzG~1<(hFrCjhM4*Sq((q%$hv7HQFI+ic9_Q|DHS%sO|or)Y7H-Ke_+q ze^@=z9tk=oE_kW!mx>(z%dI~r z=;@gSGuft}oq-YMJh+~boDuL>L9HqYFP2?PhIo|sTtDZh2M#eNY>F7oUu`sqzjiO& z#bjoqDv3*;`C{S5`mLIZM^t1G*shTJk~?b?#D|M1Rm-pjK;_p@*7`sXzs#up@13Z< z@1LoOyM2!aGLt4+b{yx@+aM3K^Nw>uJ3t%AAE=06MspQr;+F#ZcvO=x1R^<_1T2&PBQ# zhV(3v_K=l|_8T0hltin&h0Pk9+rLXw>~3Gbd!3Q>b4w5<;)M~(bZ$R8fWoHjVklmP z510=}@!EGDAJJRHw_&&!{)t&9+d>Ble+wubn_XGK0aTt!H8H6jIyP5tO!wWu4u~R8 zUNO)j0y}DsYrIJzAzj)O#r+5)0gBg#IbFv5)~;DR7OV<4JkRCtewZ;dhTl|kB5lwytU8C&XbT;jz8U@cGQnK^MBgJ z#_{U`yj?(ckk1`Osfc}5ZHBa5Ij!_Sma$cC#)urPMw&DSVAA+}^Nkf7c(_8qe{C{| zG}>ADjgoM*UB6NldBB|xC>(oHc)Y}5a2UguA33(iS0s6hvjt(Aw2)(pFX;b`obvH2 zAq#0$r?$h`&)376T%b)xd+{)r0ZNBlqV{Gl1qr zpz{>7nsfeVn0&K^E&h+ zIkGLaw7$l?^_bG|BV4_C-jcLgID6b8EAkx(Ky?=?v#6PKRaE#u$%~7{VqV1NrfIE5 zPQjw~vS~5NB790!#35urI}xH)BRm2sKpe*xvX~LkbqJ4?2{ZgKRx33^{Q+&^?6hj` z1Khk=1>f6$nHQ~HPn7`kw?{#f_B~6hxuPr%gHOlfmx+x?O<*Y3zCALZS4gWA>Z!Oc zGxc=O@_%i*@qc6jxj-NDR-&Aku0kRg+gI+vpbNsIW9*AZYUG0*sWj@dQSNaDbMQ%a zSn(A=_?<}nqW6ZZu6P6ce4o86Ll1%Eb}%p{)6^V;A%<>MGGDSVSo|T&iVE!&n0is* zgi9ZCf6bRkT3j^)9EImtyE zUtr{yceAc=z9cvLl7`4uZWX`c8QFyhFB~l?J6=de7NLTMz;_FEK(=Gy5%^Qyuu$;j zOgh?{xsZ=fOKSimlk$NGcuaCzMrV|R;419V658{cgDvu<@-t{KpmR6TG#-5g##4j@ zn<*2@5Vi22y0lb0huM=lVu0s%Erkt9(DhSoErsS1-buNt3u8Kfx#lc_S-1EwtQz!) zo0&606%F||^b%V8>TF;|pYUY#4I&9+QcS+6R3Vt`J+OV@dyMbe41ZcZhCzjl{Bm&Xvr=n#8YVeMP{#y+|WV?X;H zfcmcor4(sgJ$sp4xNPrq1g(SoK__)ws5Ckdy8`h$AOeoVHf0nEujQY2RslaVW8Z|; z`#qgJ_2S2ypjQeRxYi9Kh|~s8ZV4=bKOXoaAGcZNJ2%2~bqzPcG*5zRG(v&LkZ32> z1cv)HV4rZwJk_J)Du+<|<-=nf7jD_GFW*gNMvGx8FtnRyaC`kY;@e=~9ZVQ)ET}}u zM`inFel}y^(62M!T3_h{xd}S9oOOZ!pM)bNteLA2x;k&~dmCyJl0 zL>`O;a!s*8AtydjHRoQUkLz%;ewxQACZX%i#ECH#+rqf(*?^%o#6w^E9nBNj2y)j| z|6J$pTBG^F#0KPVI1vpTZ2taSonYXLNHp2De6Rc&Su6?vNh^2vl-}PX4WDuwECHLs zs4-IC*!yCirD402iNFboH}5i&+WE6*keYt{gSMCNQP;6?r~9A|vzvnV=fD|N(GVW^ z@A2aC#WZN9g_jM6_{o1FIJsw^EOy^6V|VSWu?bk$>sRgdRgCUe>?Jl_j(*NIhutPB zQs~T2t8Q#93GYj`#ehrk6bm(yAV<4V3m=ovi{^mQd( zYe<>n#jr?ez^I&a;8(F#5v|IozKt6ade$bD9y*@Or%`6}BDyvX*5T z3F)&L9}E$L6Uz-Hgeg`2t&v!F}r7CLHr7+J4uXh(+Ir!q%; zU)QeVOgek{%6xppb6^F=(*LP`n{T{&CXdlt(bxtb)EFy%Gb0WpeNoe%OM&!0#jKka zZ3ZIYJ4WKSV1Pal{+9D2^zF$4k<40FZ1UI31D?unuPeSoCD{BsshV>feuoZMZ!Z{8 zMDwkB+kZArY1LZe3}5JwTEz^w_MS2iY;e zpk^C%PNZ!>s7hk0nCiWc{;1R|vYL)L+d#MS!!qaAdlnu`tjmd2e2Mvgr5_e;FfEp0ohE%0 z;A@#$k%RmUDCiaXn`McdQ)%CWIjlvLS4!`ok18oGc_Vz6eBq*?`_&*yzgufbML^T5V|`4lmua>R^%}^MfDnkO83`(yK3{e5#1qCfZg}R<3x&M|;mcm~nYaqZm||A>d+khj4-^_kJIbMjj@B_<*#Nvt3E zz7GHEI}Y6xZY1i))uhy5G^inDYq5_ z@sg^k%=X*|u!LfTx`D=g3=!Y*w}cW%ZawxTWCKf9#k@r^1p)rn})j0xkm(e)BO2yuth zpaYI6AwQphjmW{9OW&)Ss~${%6pR%FI6irTfn%LT|HWoYjp6A?JHXlZJ+NszjtV6&-QLF zqdaHRP84wkt}^TTHnrI+5F1fY&oh>H0Jf8Tw0huGKli}g)yE%^G25%9RPCn(u;$E_`eFTT$7F^2=Nl4;j!D6+x$82cJ?u{O<<*xdx%;aY2ra zjq7O2jI*@C*GJ}`p1qKZ{Rbl~Xp7F*~d1eg~P;O2EgXCR$@63D?c?GhN zdJ!W=VY^=DfvOTVc@WEK!FTr(sq$q2$QALngk4bp@8zpJ^Vfr`EU~%Ht15L-#$9p_ z79s2kWj`J_0uv8%1c4MM^BEpj{s6+pTas=DBoKJupke*Pp9{k=6K4fB6aKd_2snLiLRx#B+a(5%VeXt?2+>X zV~i+8congD#%_FE4v~TS=8?oL@%%SHRo>6_Q{8wz()a5f75=n;lWDAx-(6dPd%8?V zXnigneT1M59)hc~LF<+Z*T@v~5P*LN8BG{ck%kRg&Hau3g;5Wa>h;MlAA_Ov0H<=; zJeaGzl`j0qLsa^wzKkFEFqLjgW0|;L{k^kx64_^&cp!1NmgCQ|>}UNY?MN z*st%#&*#?&cg36-XsANJ$Z3%(`RYoRdGmVJ(&>IfG;wxEJH*Mn8{SBcZctDmHy_cykMB}gxbn)vRjz?TPKHm7cg#6dIwDKtbA*1k@*-dHcJ3$9y1I8# zJH9m~%WMpJz-8y+3nL9$_<}$#GnK(8Z`G*tt^EGm{1Gl&S$*Qt)YKjh=BsUQ_H zo5BPbqGM4H;iO@0!j*k(`g}FismQ5~l>;U`Y%yi?ubK%%an85_(`G0N*Oh};u=+UP z0H1~ac+W-FR$cymM53R#@+BOQ3oG}s-G+g~!snu8s zADz#NSVk5yhI0v-&faU~&8G>_BbU!nRF;#mASb$1R@$Fg|0*k0{>G{S*vlNeShFx1+B@pdR!L*ktk7^1OLQ(GBT1*PHl7{nS{l){J)(Kam9A~| zVKWC@Jk14pOIn>!xO~@hQTZaKh(K@w)rS|71mMa)TAsIhhE5AJ%gG-3WlIAE0v)W$ zm^FwYyU^xuA0+j8MthhlZ!|6g_PZNwSBGVEd1~#ZHQcg2J`|nvWiLLsF4O?i@=#?J zqwrj9+)}P7Xcs^3Ic;>9u3fHMI%_yE^$_`uH@obB5y(Qh}iFEtS>wNQ|TbX3-iB-TYYcvam*~G*IR#b)|TDd!Z zm#>BKd%Z48m{n>l=I17A7M81i;uV0!0KaF0{hdcbjh3!T!=%)+JFt{I(pB<%H6;sI zPk}lhFPp~!*qc1FMGR{e)F-$yEEKRE}Nxvc&mPN1ebL=bZ6ll^L)%{lhHkEweC-yBhI^GHJZvt*^Hzvj!Y zxZU?w@l|#1k=s(yRdqii`-1ZrnV2UP*&lm^fq!SyNV;-9PlSj+St~ESd-jmJWNTuE zF9iJq`Sdi1GY@ zJqa0x>-pC|z>-UQ^F zHw<*a#aw2;P5S|!tc`O9$4_P}|452|GaVK7-ZT|@>u1hMD$7l?Fi1}*Ab z;cgi*Z<&0?s%L8WElq(LU{vF^pUh0jUj@!lFlSSsc6;5qgNHJ(F)~^myj{2Td)c7_ zSi|3SxL?^9f$&*o0cly+)XW`Q^xSr@EL0>Cus5 zTqdD8>Q5;%v9v)KjO$LjYg#6-z-=DDEc>Bn#_DW0O*EtW%t$Wzy;L^;C=fzN3nikX zdNGI*t=!K|&N3~rbp*hEXGNlTY#clTqbo#!p|xn*7+8kuyqg45@XWDM1=1GIhG(#8 zgI9^%Nig9Mr#MBWaW{kO-LDp-cUjE;-T%D%Z#YP-eB6|_CD+0@s?aLmI@^7x7ia!W zpVZR` zWx)9+olIPz7Nn9$B9p^HJITG>FR;)p5*H`8Q$GKL)i_~=4}*vD)%j~r$Nu1?DKnw6 zXTG*1c8K@ADXFQOuaJZ9h;9l19!?!q!)n!8r=9&<4Ytt=QZZTykhBw1JC2ql%(XNz zu?`^v<(|5_^R#ZRZ*1%l?4iBxy^JezQ!Uslj~ z=CyF%=em5*ccn1cX?E5uAN4ca9b|yV_Gq|;wT4EOVA!Ye(gE9}TNl^QS3%w1`;pYVZ|MMm6DR>IGwPo&K19YrQ zba+*o?^jBA`(59wD`aWfVW4Sr#K5%!?gw7f*{X}*_V@w-WiK$l;@8FZz;0O z?TLq}_yDseVVc9tLvl)yfw+PUqEaM)V_##Pt{q)=ot2TZU#DVJw>-ii8-e=d6Y@d= zNRD!H@{{%w5H~qbq%Sh;)YL62UU#eBM=`?V?JqHoUBS3lx2-ZR<@KX344!Q6VyPU3aK zX5Y3;EqsmgmNCNIo>7nevQSSXJ})gf@7eRCP|doohMp%4MJ#tcZ%dT4m=j zIF?`bJV=c3$bu;4Rg>tO6|o;_i>q`Jk|lZ!&;(;1J{~W&m@^#Dm7DtZd>CJGCedxM z%lnJ~ejXT54gWVthb&L?Y2f1l;{SK^3Hnp-SmdWZdEf;kVAnAAK(Uw9M7BK?Of{|Z ze|RJhCu|5HJ1FDOl3(P%(+fCwAbIVDcO;6_mcf&>S#h+HUWwcK*f>J06z)Y9yv}I_DxSun&JG31kFMXw{qZmmEm(hxVoT^0%I!AQ z1kT@%x}R!iFW#KFzuvfypAbQK=_56|k^qbO=kLn7bQa-tuoTk%NPKXsQJ+{e{{4Jw zYCLND0JAtlAA9wbNr430(t4!crs>mhmkx_N?}+#>eo?#L_(Q<{7ay7U!VvA69N5UZ zsp_x{f*w5l!Y#uA*o_;0?ZUy_-=KoPYe9S8W2XPoR?eEXqXYjygi@rUvw>{7qXb5L z(#^fb)$sj?LxY4GQDFiU(_H?Ru6XP3)3}DS;H#>;a@4Be7%V8cq1#zewF*X?FDQ$)^Je zlswLTV9hGGQ+_@2l!yICDdx`ASN58I9L?~uu1x4h%hZO(qdpG9R@^ea)Y z#V^`qtwJPs5-XGZnu>kZ1{JR&?34+@^1&^{fe+Y7OutPKz;r-V4i;7f-|;`Fc8d$$ zO|`^{`<~3}fZrR(+Dq1*(`veXCsgkrXU~&ntawg+;i?q}hesdp|3CNKM z=UKnti=9c-NsIhaKJut-S$$S>nHaoH%hKSGBR55hpXlJdua$c9)XyZytXF* zu!vvxetSw0@l9+!^FjZEoppm(sNFvTM3#&>yuev~7||%BoG#3gE=J8HXwE=tV>?HX z0@eB0?2vT9?r5VYX!^tNBIh727rt?v)I|)wJ^SoRK<*m@pw*+k>z_g!ZNjb*U&n!tp0pyPRW456OyFCf)t|v7-B|?>Nv2A=n-h>V! zYRYk48X2vBWn$LlTYt520TaiWR=<{w{LE?E{H_P$N0o(Rrmu&QtVd2jglsQfH04&$| z8~lCIDOes_7$FbeS3x>266*XyO%$g?^JJ&9etALYHtFS0!+WB)7r$qGRaF}I`6rQY z@mBG)X0~Q2l+kqH;krEw+WAlvtF)~rAq|M_SNtEzX5lJ}3$A;6`*h&a z-eMRZt3;=(UN#_X7)uJHc8vPz?hK%Gw-JdrW>^3n-E!Zhpk%0&c7r=c1T~IwB^n36 zaF6 zT84jh&b3~d%I_AKnlMcy9=E-!3XF@2$*#_N}_ ztVY6yXcPtCP>eCLY9q-In+~oR?iU6KPeeR3a1Gt#79=0MKoV``gl$v142B?>YnY(iI&ZZ|2>IvZK4e?q1A$`bh$F1#gTmC9TJJst zC%XHFsT7D2Ngdb^u+te}xKP?9fB*CY`tA$#CHI0)oJA0+69t4C6_wD(R!dW)GzX_$ zp*Hqqq~>knX=hi?{#9^L=nq-Aup(pY_Y!-~161?fwrKeRMos!cLQWaf?eD4GoY7+t z2yXH3ZaCe0b>jJFuTMn5&4$J0#&jwH#G#!~GD|w>ya|K_O&0EgD0J>w4}wBZxeE%; zQ7dG#(Ng#NIjAx#Ae9*^P@IbiI?!_@FP;fOmgGd^7PG05!-WWxM}-Pmb6eFfjeg3e zlvU00+q1F;(|6qHcKpX6SK`)_L7Z^IVp%^KSv=h`SUg@_r_u^i)h;AP6}Jp5&oBO4 zh1!htBhbD`94};aOm4gNlPm!JGIO64=H-2t<>mgci>pi!(%-LDZ%w5; zE|AT${sXJtGm}&PW7W0ZZ~=S!xvq9Qrz^b~b>zpf2_@q7J0Mns3^B5#D^L>Zjn#k& z(rRvJ##4k!Sp52<^brx+T-{i{Cj0cc4Lz8=+flpDg-$k!Wj`Y-{lI03H`+$_lU-1VHI-T+9x)+Bl^fi^&15$% zWQ(^K3ak2*%Lz)^sGf(SzB~A@V0EGHxeE02AmtzhV$Qek&fov6g+A|#JYW?9N*mMf zVceTlPAXx(vHt=U_r}t-pF*4?8M()$bN}Mz|1zI15HHqaYh7#LnHU^kdZMEJI)`86 zxBV?09{8=1XzIW%AsoFaE5;I6RR;U!U0x!!-F9NO`t`aoj_#^P?ZL&2&bG8nJvY1< z0E$5UJ`ym?kY5l>sjTQ^+f~$g?Q4;QKga+=)=*%mC95@1&be!A=wQ*5Px&M?iLgN> z+KfujZQrWIn=d1VP54l}k03c-##P|-nVjmhUk_#i3dL2~B9m)rcz?zhJMt@8&Rw-Z zso(P``^juH@RgN*TX*)>N7Hr-DWHZBzCv9u|CYbCqGxmlnCvW? z`DSW?bJEQdCO@m#eyQO<-ma`ep#VeXfmvkwncCw3?4qw*Y--q{?hSbV2&5=grqshh zcE2A75i8Egk#B}8=bEwZ+(&w$jFG_NdXQ{9UHr^n9#8>h zmlY46fe7?b_^Aukg7p{vXvgqSj|K91b|Ux7%xD=(tn#UKfIlWgOIEu%ar-e zKtRLB=6jt->NMGxTxBwAtp}lyk^8MqZg&bLaSk7tddFl(nWt@`MI-l4CaJJ+tv5>* zJrQsXDYVL@6@CY(JKRpf#wCPPGt^6BF=I8Kr7MnghO&*Frzk~1GV%BpEC}*CHdB&v zg>vy`?WWn-sEc&Ik|X?kqh*pOxn!IXa91b*eGZ6YFS26E0P%mCqJDmCADFm6 zj7Y9Da(9VrPCe}IIeQOdJTO@0jAZcU%C<4-uF*zDhTQrA-X>v9x5i+Sm(xIkf_U`F zTDHIEyJ%xwfL+KWTh@X_Uf0g$_RO&>{VcM|pdsDI-{^rBdB#T?OLoE!ntnq-Gu(gv zeCq%mNApEzLHt3b#-QGE%H2KZok$PPern!5&r`!^x$4c8Sb1*Hl>u*6z8$gLA9p;< z`X2xE4dt?#kE5M#%%qb*I?sOF6d4%8rnE8<2=ECSKX9P{62h!9svOSkZ%-D-D%x68 z(^HM@+q-sVu#1Pa>b_&_XSi}7&sSQST&n!*q#0w^6$QsrBbA%239gs@^b#eG2fqqb z=sthqtpbuaPu-JPBb$t%7IPKrN`gK0bM7AT?(34%#p$Ro1GJrobgHzNC-dWwah2j( z+GGYJbvmmI^gMu7-3xl7!C^6)?tDhaGj{xZ&!8^LOcYRTSTNm`oH8=3g{9?U<4+#hWEL7)Fz%poz?Z1% zW&6(qW2xMbv+=y?KxO#w3Wb3i%?{>RwEx6W+)G{#n)4c59cQ|UhU%3%M zv<1JrD_{tsi@jo}KD^RKS;C~x;~M2Bvi}izz`vE@6I!Q{j}K%U6K&wDfKjeE-t@RV zuBnsm0am{*yz5S{#(E+mX(s!sg<7?f2u`U*XZ>Y|-VLx0o|+%?4oMuhdJ6)rKpt67H8sMG#Z? zeIqj!Mfya5e1zwx^*1ukOn^NZN{x!m+&2)rl~IWcCzLETc_ z-hQf}Z)7N`_iwNB7ZR59#g7#u4R*=3t|J;6722Wu$rpn2l*5wb%0vlEQN{0F73nGJ zV;G7mhl`asjJUDn!hePhZ4WfPbs?mrW*K|Cr_>X2FYKG>*dFZSe1Q6Sr3<~-9u!Zx z9VG0+@vpmM1vaPR8~AQ|gdDj7Pq+X6Q{Np~(4lkv;cmr8Wl)(^16Bw;7+II4IWmHI z*&+)gy5}s}V1sb|k-Bl!SAapY!mNjIt#jGln*&$BA!@f&gM*VjaNnb$;Rx5M)USf$ zUC#eJwj3$*t4-YUbFNGqgQ5YJkA%m0rq8$MZ|9u4cEZpHNS+8^Oo|nN| zUp>!1^MJ;RgM&J!Van*(B=E?K#IE(n0Y{nK33t9HvG9Bs)InH)k9D|ImHnPXL<^77 zOjPXC-$<vY5!HmmibHw}nvL0<}Hl)JOxoA$?dUZV#AGb^g;RBSTw0FzA{L_|Z4PBZd* z8(!oBW!;M8F{!r8f-NJiH=HsW;1F?gohMW+SF7uMDymtw*v^kam&~>4?6BGCk_p7Y zJoJ=iAhmBu8wG*`5b982lb-{JN<$^@6t_I0>OMrRu|2 zShNMHDJePAR;q+0z!M1=z*<+kU5SAZP-WZaR&jChf7@`RChJ*3-Z!N`0a&bq*M6%s zR!8OVVKR@e(w8AlX1Zw_pnJ*k+aX+k{vcrB9xz$W#=PW7&hzrfM5a$K&ef00RH#!< z7EC6q!cHdx{sO`z8p+=yWGZ}`5k$Dk*XeNq{S%DSV}PZ*gvIh#E1$(9ApqD!0K@_e z8nXv2MQbqhK{&|Fve20oWOyK_xVg#U>C4EGjo>Y4v+4e)|8ln&_1h!Sd^W_(^gCe8 zy)r*;jM2V_iT1$>UA3=v{G2%4lofG|cUaZXen};p4BcFR#uHVtuy;!XNa0Bx_d7KB zuTwy5mlcIW`z1AV>mvaG!Hk0iy+X1J-aN+N`G5MK2ExeT=QeNj>2gzn@ZqL50{V zor6Cz|NJ5UF9)L9=8l=fdj})v2k_0+?3wlhF~oU`wn`;x$PU?L2xiCy@X_bn7-Rqy zys+39$R1)InFHREhN9MUcZU#IxuHnsDA%ITBcZqidHivJ5_Qr zImoW9p!pexT-vs!e2!oq8va=5ZAzA$y*DLfWg~lq{CDM7YLOSNPeAU^D7B=x!s6m@ z82xW)<{!NGA`Z6NQVJ4BxQ2Tuf>tY#idDj$3TzkR^eh-DWw3MEBD^3_WqKyTQi8#g z>Vm{MEQ|5V?1#}s$co64U1RuN9VvXGjrg7qma!`s<;(~n~yHe_~|QRiO}*@dHxxl3BS)!-D~ z0E23YTB<`G9zH(bsbl=i3{t8RySmGW1qlDpgZZvOlruPV!S^*o?~5G|r`~$ev^9C~ zFU_m4Z9FN&x>)a>^;Z&s?Dejn=PeP=koCbN6qdqiq+)gXBe(G_Typ(4y}>oB!gY#O zKciam>&m{nsWevA&J&PQDya-VYIY(%U{xucbOKyz!pGl7L8R8KSOa%PDiX(S!*mc<@Z4 zMu80jQDvv5CZMV_%vf`2RB8{*T;{nfG3m`0ajVqI{M$>_s6@-FE1XQ>Ne}y;%gUG~ z1VRi17&j6TNFZ}bntptIV$+*pu$+8W&g|Jm0n2*-eEY3>#lItKdmqSCvHHmO@>m~; z=zym_3R>B!3skUjkj1@x^#2~6WL0LCM3lWzeX=g`yxO3V%9ilEj`KDmewW{E2%mB$ z4=DTY1OebdL^3mZxM|RPb;-2%V4Y0Lu>bUPt1&eT(Fn>DH%~4q4a~Hn?m#fVj(=Kh zNbveZO+I44F@X3oWF)Dj6xGdv!Jbl4^|5KO0n`0q^e;C})%nTi+52unl1rH|hE8A{)k2q*3>kwz%9lY{|n6t-`*n5EGUDb9IqGs%p z5p_??cf#R(neEgq-$UWftS40rSgV2!4@C9Xn{HncP8>7o0RyS!yR^cluQ&sHYXZ#1 zcuvm?81y#;?faYjpTr3HDoxibD;I}UR15xK>mdFRwAd#Y1tNa$+Mf`Q#GlX3-(b3- z82l2}NK2w9#-5cgm^!?pqgiHeYd&U2*X%3yMY7F064u{;3P>L+A$#XiN|-!{bUS_r zmR3Mi(Do|fv);#&`ngC&xhm^bPsvbgwI@8y^}DeV8IyQW=acY-=-K^K)y-@3ftyLRa0 zgfYq@L8Z7?x^4Vm5D{$s@sB+5B#=uwEfZ*?&OD}(KpXuxi6JsNnoUqpEGcdOaT4xn zq27z9eZSgeQKf%?`UiZzV_F>t^UhG*F9{PtwL=ewM##BVUXA*L2i@jx*0IzGW(Dj$6HTio2>zFh;rT%I$@k@) z&uNP{+0f%XA$OVO>C#6FRTlZ;MA^NE>|W}BOk*eKtVIhcUjNSl^EC&8NVlcqDZB3A zx-}9?D?0*ArDCoc4IeS3Vu+8u^2^TcRJb0}|#|iDo|;P> z23DgCn`2qTQ+~LX*=`z{G7ISCd0Wq}bNLBJI)5V*kC^+{T|d?Q8#K6jc14P)0Iv(r_` z%Rq><9OfR$nWjkeE`O`y{jt@Q>Cbq|y`32(Y80kZyhP=ia%zGQt!Ca=B2GQxMsD+RrZa8vT9}zF=*ilM z3{FMTg3zOTX1ad;t1_ioe>iLOcs{h$YIGxRTysJhNvh1(DOah`2ur}5uj#5pyuz@c zD8Wv&;!0n+$vh`3FmnIf-~KC<*Y|{WO!AjgLI1%4tEO#hAVWn{{4Rq=d?6hGXBzEU z_Y3;-ho7RS=R^dEq94N2a~qFZ7u%N0$? z^U%NQHflEFCkwBfhA;i|Rt;%-z}B;E%Z8YOg8Wsd&)roX4N1}R$1ppDA9RR#g!sEH z#}(Tx#|~sNs;`IHB>%C-#9%p`oxM+O47V@3ey#j?xrvNov2b$>K_F?0ITv}vqp?)j zl16|y62m>aKaj8Z)E2@0_-|2`KDH~KPIs@`w;bL%tUNuuhw$k*w$i8$rY|c)iox$jZ zD3G{MO+rI7Mq<`MU#W9(nayA!6 zNry2o=_b(JTk8|mt}CXmCudlV)fmX5D#6D}5B#yU(U{`oc*i>;y>y5{<0@cAqWAH`T+k=%Ii(pHVt-wB)3}8oNAsc%W%R;2pm;y!$M_b1 zv-_R`U>CA8x%}r{W#SiD(UO?PsA>r0G1HMFXi+27^vki88*Rig>*(_XjXVuTz{tjp zvW4sv#=V0zCP+-%29}3Bv#y)`>FJ75PMn^h2S){c+-2z@^7U#o0+*<1~0?C1X0DOkl z3gFzJg-nqwI<^(1$5Xc43$NFzYBpQ|A$2-|#(hglWTy+DabDdcHQ2YsMli1o2Z$qh zYz-B8Toxn);b4}lOZ6G9XAc=a&pZTgMyKnRq#2eF#8BDN&sx`G!z1u(;tW=JM`{!G;9;c;2{YO_=3Ljzu5~|urbrB;bvu=70{VbpO zB|Q?|3bi$5}hIE`>#nb@$KRGm2uGTUJB%3DdTTlTxSEcQmE*h;{|z zcbUW3#tVIM@njbf9|K;m9!DSfocGv{+{y(Ta0S%{gKAO9;;zNPFQh=O{IV~up}_DEYHMW7r|4uj53ZEEavg%h~@HMO3=*?0&f!COsOqjRlxxt zG;hV~M*C%0^jaVh|LX-9-IH@Rd8DiWd<~r*`x!ke>JB?l!+%kL8Ws!X&I;YX!}BU& z$I`o1jo$b8UU2B9Luu9j!{;}rOlo%eZu);g>b@6vET?Nd9)vuOtLbZ_N3MiQskzJc zm;;48yz;7v8bv<;Y440ZLqwfb_tENZiE!EL_x0%>+k}-}j{3kV1>}y@D>75y=ha3J z8npk|zRK8Tif%O)DPsuEt#Lv8x4Aw_xB#Q>*WcEBI9Ay?@!~hDOM{zS?x%6w zUE*jf13YK{5`H1v)>^I$HyE@;G2!Zu{-Hp4SlMsy1n!Ivolk3!g5?IstpkkqpO95x z)$8te3-Q`p`<>Hv6ptz~LGJALAM0>;&QHXR(9_nlT)m2_hrn`P9PiuO`Ipta_H*2@ z*$PuNrut3e@zti(kqTc5+>_NFp7ZAq>+Qz^M8Yn=3D=!C0LiA3jh$cezvUHTdN93# zQUjrSWhVZ+iT{6uQaPGJDG|!5hWark2V<0rfSO1WnSPfYWJ6>pX0^q-bLMrnyL4=y zFU$`TB>gPP{=vxlIP(%vS<|Q~aa@?+MY&yC;nYf|9q-NJ1BORX)mJi0aoJsDD@@$@ z*_9DX$|n3wjbHY<*noA7kR|&V-ybVP|64X%y^$6SnrB4k@|EO71Rs zoX+bJeW+K;H)EJRXe_<+%W1~|MpQHYHm(Lr*H^z`ON-s{u?KAmEcLb${B0fupkj92 z`SkY>h!RS^)?*tv9hrgh>cn`Nvl25hR>szZTAKiFN7MJ?;J=jQVJ5?~nC<771AsLJ zOwa8GD)0vbCFsR<-s#}t&os$^%N>Ep{q+nskbm+g0dMGNVgkKXv(n_RMi117P{rbr zTxdWd54rNbVWg3bz4{=s($dzu+xFI_)xCY>YL{W5&VysRmS(Zh3)g1OfmW<1DAxT< z@u#1hXD#Kh2|E)W35l_HST!oU}^jO={d3wyj{GntP;9NDUm_H1wd!N;28w2Yv zf|q%ICfj>V!7B@nROdkbZnj-khu;O};Lg_v#!3KI;|Ec)Q+a3a(q* zXu)y?r975_=cY&2+AHd=PLwl5D7h~pdBT=+p~eFRaY)<29WEk?(fDdXS!wCMuD<^U z4t?UI{QI#BB>+ux0obwoBJfkSx@95fJB#~n06ar}W7d2bkAS3b)gCxzTixZl9?wHG z?w7&13)S0v%xx!5*5cx$3W~UdX%Ac@BG3Y-MR$I?gUoG@d>Iq5vF=zMpP(4;9lzbf z0l(4Jw|jlzmqSIzoe5$4_FcP-R!1xqewXfwMej#Cu@c{`|F?kAQP$uU0>pESB02!* zCV_>;8yztX4Z5O!HR3|OKfSCIs`SB4NrnyhC_yF3sM^W zb3|@t;d`6Zti^*exmVq6V3dXzF&2LcZj)at4L{1&(|3pF&=idsI{RUGeVP-~^_j9C z<>257CWVhwkOOqfs8BicrYwhXisaNZl<>Kw4=BZ3yjtr)F@s!}^n|@^SA20r( zddUMkhd<+}(7BXMn87Cb1Fw{*>?HtWtSUs1Bt&Y6|<2 zvg2hVk)x{k!6*5Jq}8OF<>Hq=r#zp>7B2t?+l*5_qR8uapn?y3e+525kKUe25zx+8 z!vQlS3DGaaJ~#Q?sVyHT%&YIzvpzh1UX`UfLt~7;wNY6XrFR-~P5MkS`OMF+5>Fl8 zf5J$$ZfRx)PnWso>Jt?`H*x58`ND3DcX^$lc+o>cvLEwW`PTc8&W&M-H2a6Xz{#l6 z@vN46UMTuY{&Dp~yzG4*mFy(H03aT6Qd|fDEy_<{=<&*J!SaEeLLj=WR!8*u3(s2; zl*i$ZTKSgr0B8^^--ernhtbSl%8T4)Vi~E84Q;(;JltNknZD zo{zP)TQ#W35X+J$p`MuTIP4zL+rV+_nL9r~6diKqJ^$xSt4Uu+00nTG2lw#xkBFue zrnKevfG=%O+cMMi-JT&P3z3zI5m%c1g2X#f8bi5uEbrZZ}OrTNtv9qA;cD^)LZ8|U^ z6OJC=B4i(5Knwm1!iV8Z{|JP9{>T?k%l~&hC2Q;FCa`LsY+Wx_v|KQ4C0_WQhrp$U z{3fotn*gR#E;TyuH+*;}hd*aD3Z(i6QQ{P^!5v(0Gk*!FLe5V>DBazf(DR;@NI%tb z#TVr?&hWorLtWwyxOe=30R>R#JyyqxhbmrxKae;i#M=KWO4PpR45C(@865!m?!(Bj zWyyEZ=g*8~lyxLRA^=R(v({i<8Co!?KN;68qMe_$6RooWwIoq!qN0 z{qa@Ie_vn`_Xnw!*o47Y$Tc9_FLS#|2xo$1ex~-ofR3+UvzT2s*$9`jFK`BSoA!jA zhok3bhZioI&^4lXJ;AyAzQBUpt~#LKPUF%STsqSQ&(G78fWOSPRgAtbZuIFaTHm(D zS;x@Mc$a&yCzp$U=*g=RzgRh>U9?P?R>RB+z98=xGzYb&q zT|x;dbjb53xsXrjovXvU7)}z`0W8wV+j%F zF4G;65_xshDA%5EZA8qi($&LdCB$&VrU>FoRw)SFPyXG*tZZgYd$m#U&r8BgE>X&7c%8R*@;B(qi`K4zIr-3qbj@#t#ECG>5_7m$ zDwM><%HlXgBBCu$aoNy)1Mj%1Rg0cS*Cr}b_Ap)A_p}TAvNFm3OpR)b> zw^K@JEx^+OZR1?R$fJO9#GbU}1gaFXV8=^BA^vGq#D2?tR!r`l2Uj}j z#A*NN__))6rv3JL$Ez#1-C8%F18+KDD^RY`kZ%iBX@ae4-+5k~uKd8eiZ>hjMV(HW zD9(cVt1NQBufkPprDC;{5FAAIARD|{w?h@$Xi z5KIPOBSxWb1V;FSH9?FKmsj%APbaclhy~aQG}J>|zr_*IfVdu?1cf5;5_WG0jVuZi{E<)usGeR*DvdfHJBfWF zCiE;)sAUwVtnnK-qoa1z=rEU;={rHn#8v)tH$Hmv6t%@29@eFGBuj#bGFn5W8r;A8 zLJrlAd+PQqQIZI00W_=2V0Cdn-;+^v@-0(7bnGLAb7FLP$sydLjt&1QH%(EI`(LO0=)sW7T4X&Zl@q0EU7&Vb{G&M~<2 z^OFCnUeb9+OQ#65-sPn5YZ`S9`Gr34YS$KI8;?8W+oCM^0CZldcV*d(bwF&-DKJ;H~uJjxZo<*ZxMam~-rr-Q_?~ZN=2q6M7 zz_--t1{wb*OaydBL~`D{lUhf81c+;R-SM=3hu#o09KbQyuRqa^s3c;lg@!a;JrYiQ z&+LBupY!qGSwE{N z%Fh+&24?Y`U>UEdt;DKj>La(X7T_(E2e8Q#v1q7ew%`lE+W&OO;wg~;Z!9omA)xur zf{@%l0;Y*T9$+NWiIPP7N^Abe#MH^RYUZ{H4uxP>4lpz4Z*M#W=)2!iW_zqki5LYM z+!ed%J*$M}=t<^;^_;;r8O1wrRh(}&e?koFWh`9D3EF?)26Hh{mMwWkU*$qyDGhRB z?`~_In$e~|2g=>FC=0Ehf9_uHtKV+9ceCu^tstI<(t_!~DNE0sl08NzAYktL|3jRZ zY#W1_hcY5&@%LsV98*u+tX)awlFoI(WJTZ;rcBa`!%@%TWjfj+YUye@pZ- z*|j?Qe3i{a3~+jx(C5U^T?HulY?gVl&X?aMRb3?PrPHixOh3!fja}9;3ufxrEJZ!E z2bmIbo2^^!g5INlSg^L+^+qNqA{yY*uP*;ULD5rb^+uCobMzz(EvHs|yFfq$I|8k@ za`EizgM+U+Ld{#L7okC)$YNA*upi64)z?-EdDmzg9#&3*L+Lq(g|7l0saOLsfWcfL zslZHytWGS8oC*X|{hZK&z;8Egc!WS=u)*Qwlm_v6RQ0|iJ>QGc)bHcc)R*^hA=;F# z($A3?Q_Ze?o{j#B&BfhJPZ4c845rsfSuKF zi#iOyuE;T{*a@aP;;9sWWCJSHuzD%4`#r0O@3SK;WOHz{2ax7!9Ji^DC`@xU0pa?@ z`&A+z{onR!<5fE86K}a>!lgun$KKF@$0I&PUO8GSe*$GRk~e9hqhfI9_U&=m~_r3Un9Z)`?OQoQo;PzRhI&{H#H>N4@0wW2cOM^P= zxgYM9Y1bx&l6d-eylkyc**87_jKATD3)W)xQA_Ldatc4b*R%ik;jZ#U2dB-2 zlpeZ??G@5QpZUi0>tL#Lm3^_tX~AT*+3+Glb=|T>e2jEp>wsD*wJyT`5Dg z{o;o{TKQ+?#$UtORs`9%O;d5fiMZu*uHP`1O_i#$n#XkS1#U z^hAwt1?M%`m-b#`ugsBM1E+cVMMRW4YidMglA{d99fU< z7wMJ%AEy2?D6R%v7Df{+cyM=j26uOd!3pjff(H*CB)AXm?(XgqELd=d;O^gg@45S& z{fjE9V5VTrBi;RU=O(f22JvCWaEem?!t7IC1YKv@8P3{ag$;!t-DW^C_eN>`6gNNF zcivoO1FTpyRbwM9!-?A{LzK!A$VmiZhHoKy?g{u>^aDHd#RwaT|37rCD!sw@LIqX% zI7#xoI>AbqMGaE=#IcLlo{|r)p(lyFuK(z=UvG*Z&pf*O_fia|Zh5*wfXNUKVAl@b zbZfS*8E8K1aUepA!uL^`-e+|-=qcIWn)qy3S$d@d7#K)EWP00T90)U~E|gDFE>=jl zl-;`F&i+@gD6i{d&$Y7h8QIQz=1(QCea8YAGrAOd0<9JAeMY@*ojLt%oT5tB=I%U| zNpb&dp@MEF&sV{Z*%ru=DAoLNb#nz(G$;^BlU1 zALr-8WT_Cz{PRDuIP19nGBGjr4WQPXr5t{S%eTf(bguvi`s*L4LaeIupv1&-E+G7w zU!&;p+0hSLKkT#LLqDK{P7DhJCiV{D>Q`2R;Q!0j?7Q)W@Jz`gxUg!`Mx|wC6z~Zs zV5P%0Bw}nmRfu>{Hg{nH@E!($LCDC<)vxW}37nCQv-|C=ol~MpP<}4gh$@&ndr4u? z1d4D8u*KLC_(!9-j{3VDtVI_Sk{4K*!(>*d1^3{&YwomJI$^te`_1u20HFy_BXqjS zvtKzCe?=Tn8mP~0@sl`V#nZ6KnNp>J`G0n~s@J!~?(U(aB_$IW<(mb@vqO6sOtYFd z@CDHmH-A`r9misYzjy(bqwwcBpGG;u4io+<>HfUaOg zHyPcXUzV2r2hRpk4T<#df)s2_9Q7Se;y%guL80-^N^7NfD%VwMmQ-EOswN05P05H) z^6Zj6$A-59E3UvP%U+qWt#d?*kzbk%Am?_o%9J3Y)llf2{>Q7Eyg^!@3(akQVC5dX zPFFd4^$Xi1i{rq4r7tGiE7bp~_j8N+s%C{wEm7=uW!MAcDDU(l*Zx>AS`JsD!pEu; zHs5VLqt4gyzwWCk!1|S>?|a%9GAxKHu``Z^#1r#m@mg&gHMFYnr4(5PaaQs2Z*->5 z&WZmt0JxTDmJ#v$q=u3B1?S5|JMTa?CdRl<@bDoyt4C;3kRpSnq|CSec&ZE`eR~)NHV<|- z;i)X&XU~^#S|ALECR*Ik=aPEL?@aek#fE63UZGyKi?e(3^LclSa{C~#B6#j3X>;&! z3`2hwl8mR(cR#Y=1z*jc83;bVL<&9*U@{riW<058digHdOX{8smS?`W7z(DGUIR*+ zS*k$~;;}}4Z6jZETv{SEFQYPY4#0pIuvmiRb{3Q-Od)!ZHo>oWBl>Qa#^55NQ#h1ni#*Od4 zl2p4VJu{?D__qR16~QPg9$+RG{(L?GU6-1z0l;ZSZ%}l zk*6D{>O8;k<73(93a>0jYR{sffjDLI{sp}`hekkH2`*ebDANeFTh{AGO;-xdAjk2o zUbu#4Bwf3X3BqSLlq61(sZJDVp1AA|rMnIHWfG zQru!D0g5mr*oZ;BR7+J?KDkJvjB6-`1sKw&a)sH&z5TN4|5RIyCo{WKl3RSYP6TF` zmWx27rNVm{t@x3@9OH3bFY^E zBK1GlDZKTYGUe~SIK*M6 z%b@tzM_qLJLTs^Ml};g-xXBEfXo1TKv^GF11Y}2+R?1*f5{uDUi+Pz)r5GZuG23Nu zA!nx6cuk-<5ItmLOI3dA9yy9R%;)rvPEW$uJeXP`nVp|o84bo5=_qOJsi1K`OFHfd zW%A_f*dDuBp*+Um#FQcjfWTt(UM-Y=6N+&!4;KZVJpv^x{MfSs`niOJf4+}Wz!F>z z+)muK-SW=%qGNPxG%*=Tw$D&0ffJL=y_>|T$FV5nWRn2ijl*r57pOSSt$hP|gHfyo zmZH@s0X6IML<4u87SHb)-ByIx^?(Mky>~Oc4Yio|87{(3l`0uAfRakSTwJ)Kaj0Aa zV9g{=tQjmoZ<`bBdY)vseIF(>_N3v}QR1Ip3V<-*F*qEXK2SkAouEtxTkCDgDLS*} zI2l!AF1aAB)s2$H$h30-0<5vji?>PyLs&-UaG_5D5$%EMC8U1dS{(l6rPMtk{%GdTlYDR60 zu%hQhkF~t@qxt8jxgRRmE>zJVd7v$fCCOI~wcVaL>4zO*CJe~Qmul<-0pKl1lYkS} zxYjIFKA*^N+d_HkVO}K@0VGF{urB^DOat)M^mK&__~a!s8;!mXuX}ebYpy+JWjD?( z(`uqJNF}0?1;&d0_$h7?euK*Uik^>jDyv3e=qawsI^&0=&WhYA!7v( z1aBrOEe<886J@m~Yz3bj5d-$_+sdA=)08!=nldnWh@jM5| zTq)va=t-58y?x>rM}uK(g_JE%VG}fvFt_x1#>clqBqOpE?=;G=7`kx(uAX1z)w@-z zj>WO87f)XtYaKWIgnC05t6P(A?<p^PF+ zOWOZS!E-ZpSM~P0!+1e?zCoM}O!5a40wN*5C|@8DV*J!2p0$Zhhz~W^orR`uMCbWr z)+WuwlmPcBFaDeZIj%}5HdE;hBig%Y;hZ%vyJ z1YXXV=<`IH=<=p9Rd-)u5E}Ua!6b*Lr#k^*Bn9>5kVT%(p)OzVw2X8r$mC@qtAE-j z65kBI`ZuDR_|7p3mZ5?fgeaXGO*BVcut55Nd5h zDQ*aL1a*=vHhF`#l9BqV6Cl|#S&Y7a+zdL^D8nA2ExvextAZ5PcV=3QSMSCR3(IgD z^-S)6n1#)yh=17|M*1Huz!q$2L#d%-&Hc z((cb&FQHR-&R{Y`O5{1!`<6=czaNs~%gp6o+u~MW&`L;D6-4P4D1_n7Y=8X_r*ne% z#UPPNJ?5_Wt6(NuY(3_pHrI{vqDI3GT-Cw(45?wb7Eal;)qaqqx{t|d{NOLSFjiK5DTzvCc-vfw4tGnawAj>hVHq)g!9prBF z@|qt?TkL6YsOmcN!eQ1eOC$(^YHTa(4lgWloYL>Qm z9-~qJHG!+E8~OlLupAXN7_n@DUz@2jf;O80K&Um@n}4jIk$62np^0B;c#z(&dyBXa z(Lh+i_fW}|EuoI?_ZU)a%lfD${IWK`xvWS$s=BjJzUoU9YNd@brLA0`Dil=P-wJG{YSKhL>jkHw)j z)M3ODBIyv(1I}tWqn6)P>CxlLLTnhD;+zbWiG=zTx_z<^{2nPd_Tmwjt(cL7PFr2J^#U}Sh7+M=8KauqppunC4Vo7HrN$@Quu0MIDdZ*)OJ2WWf>Fk2?# zG5*g%?hTP`_OEGyQ?9#T{maDh{m`LexiRAce{iJ_A_dbad;X}&zoKTCE+#V8jb zB&nj~4elyLaL`oEn-2CXHxihgi+ik!nDk+!7H>9gD&={pqKY`&uGB!6ddo#f}UuB^rX- zh7qBPSESsCLb=VWQ83t)^qD83CKI{Jp_Cv_T4Fr?bl#)@>GrUrs7JN1!NI?zx zE6ezd#3$Zw4`f0@oxn{8*2j5UP3qRgqq-DAHLQSxxbXug4wfQeQ1e3P>_eOD7L2m4xIo?qT$22@C`Ah53Ho6a4 zVT;xUgg+_Ln5@{3_2DfhR5AS3y-g|Gyu8!ezp1St2nw-9Cyds7y99p#;Oz@v!Rp+Y z=Af@ihWWe{sFaQLSW>}W>I{vJF9F3dPFU#paQKTBr<2V!4kub!kC!ozv)WzK8$J3y z)58;uf;s=wsJzK>fR860DRGfrsrB~vBY#=u)jYlQTvaCLYv$%UhgEL()8$B9IKAW& zuPcIExFQP%XR-v0Z)C{mMTNWZ{4XQ3U?tUDas=f5fjW+X+B2G8W{PWsGUBE?c-?Bl z#liw=4irQ=>+S2-AP%n4>9;+rjs_=6AX$SqTEfU*q_a~9;D!}j6>ZuiZKMmiyKb(k zfdiQ>mG^(EOzl?;QW1&?AVf`YK^4f;V;pDQ@0poKdic=VuDHHEfeikF00j-Mu&(TJ z$z$`w^vmuryu`P)Up#7byCvG=5!Oh(3WP@6Kv1ultrvmHrvTS`*SWbh6bzc;BDxg$ zc|sJ$Ipg~*p_ki@7uvTS|Cfyx(?PC8+98coxqRtbor22FO!?Aa(Tlr%X8VoSNZZ1w zJzhz%A7;8b{BnQL0zt^%-#aH?4%0}TcMr*O&&>$rpZ53lk^42S=Djk>;5~0|d3d?M zM^%fwx}CLn3%TsG?!J^_M&z{V%5!jZJoLG|JkW}mIeSHrMbsjT0e_AvNUotHNJ!{E zsq(b&JyE96T84lN+z&EjaEu*=g`!VIkxl&Q{)JEs=%TldGeE;c6`vXn3wj0#%0!L+!`Jzh}8El`*XdiRW-Y4+jnsz9net_U-Lpswz zgSME|@ZTz<(lKZkh)Px>RlJ>@(SzrS+ zUNasA!D0E2Vxq13MTXTT>7l5D@ueNzo)S}boEL-kVUBvE1%<^F5%8*u!?WSbauHnC zQu3WyUsH9ODrbYZdQoon3lp8vH;Li=7{1*58c}Z^Z_udq!UUALAl?kc)SMO4?~Z}qsSVsk zk@tWYcP6kSG#IeE-aGw`cgDL-i}WpfJ04$VaD}IZ2+xY^%OmxLRq_oFb~nigdAdei zSUY~6KNAW1q&j?Ax0vY*X}G;Bbup*wLks)Z2r?eIuBp>~+Mn2BeY;W7Y23F&9OT~S z-Toc$D)|0#ZSVc=%aDY)DzY>Mkfg1zSt!5_jr|BG_lvysZ(L99-~Xik_qQ{}$k8XR7!kJZdEXc>P?1}u|GMN) z`FE3^&2UU2V!=?0H1m2E07Kn6X4L+@xH#U(Sl!RA^e<}Mj{_W@!G6`RVN$QQO z$Mq(V^0&03^83$BDNdo<2y6B;>~!Y?h1E2WxjTUH_SU{J*hGBhUl1woU0mgW{%^T8 zll0{RACUQl+Qiq}XL(&Ybv^7=$1`L7%#Ym(L%n(>eZy>bKezbqsv+mFlUf0xP8cnL zbs(D5+Q)-a=2qycBp#y<>`^DzE((c4@ljdG<+Ro81LZ9J5$o!N-mohm*`#{qY0a#p z$uri)ksewo9h-qwC!sgn7WH5MG{>3cN8TNh_hp`uMv70q$rlHmo$=G#{ej z?dAJj@Q=ZBbjAI+m550a6*J7y^kYfrXBODxs;MF*Q;Whmk(tJ6Vj0F&;i2g%nO1w< z*)xP(l4mE7zYY~vcgM8jp13SAe> z$mD8cQ&*VSrD!3-cuE*;<}YK}@5{}tdrfXPlW7o^c(475LNE)5px{KWL|Ay<&!Zy@ z+3-_y(2wvq^1HM3LD$k?2VKB1|6#oQfm=oJRtj!^Qr(RdMU&iloY(_>m`y!Fok-9X zrXP(+z$xRhmhI_a%F5MMQqDUcjT{z#xED#>ISrXnOMkQzz>eENPm$wQ}Ur&BceH-Ha_p!6c~c~GnBbZXR_KnglLBSAbp z6}(Q!uCbY;`H)A}^I1Z0x;uvy%eTvd$j;Lt$|Ti>8Mymciz~4cZjj-<5ES1~315Ki z>Mx=)#UF-W9U3*ChbdKC6h5LeC>cJMDy8MR1PzE9*BE zIhavPHp)pE>+b*4Q16D*IBqr}I11)c!=@q>IIj2Rc5CxguT3k-GrA80qjCBxm#`ix zmfPb9?63>+56$0j#tA!Sa|@egll;#dHA6Q&0b=78?^GLhXP1?D+|=0qO+ADzZVZ1B z_@gx335V6F*Y{qiht=;=Pz}pu8Hb|~W4ikRnT%v=>2aGLx+q7K}8l61sOa*-owgNlP|lOz5Nv$oL)` zikPQYXzkWDOn{2Y22oYpSM2Qfzh+BKQu#B+qubQx^?ZGznq4r!vhp0kgd|p5AB1vp zzE#WWgHWxt2k47{!R8CyrX@R|6UdN?#BsV=aw7P}zaXDBdWrC~KUJt#S>RV8P9Apd zR`WEZ`S*R35^F^OkKb3`bM7xw*TIa4hw#Z+TNrM(cQSxxl!u3qZZ6mXWPYs<6(W@L zW8iUaRFAuT#30nh!#+>zZM65{;jyu;4{~sT!*Yg*OM3qQ5uF!k)O7)GY(FOZjpiDM z$=uR8urwSYPj#V+sr}gYt))0cy;%9O&t;l2#CS1F=&#QlK@tsQw8mUx)a1tC_(L~C1(^C4Y3(xN_|WK*upk#9>_RjTC0W0@|~4;XL>7?Vx26Z5?UT9t37zwE3%*2bUSxjS~=IVT+**=*}6GzH z$}UXW$kL^Zzg!jKrV047G;cJL3QTK1;e)3VY{d$AQ#iAam}(&2hIQGQbA8dk6xwIzl`R^e-7lGQQnY>)>(oj0&&$g#9)M!L`b?+$eJb(rx|BH$w zEn!Fnw@MajlDetAp=b-~j@Z@h+RYUx?P8djvq3LXNy+rP-rM&hzi#Irde16C~=!oCFKwWBR8 zVV^$X^Ya8_1>QxY0>ViNE647u6F7!cT4V`HEVZmOld~TEGo9w>6r)GLISe0j#L_@< z9Bfc8ouN#$qY+U_qZFQ4gI}tm{_DqVNOO9kEkbjbe|pfbZQeXRmZMEt%+ZSGi8{@n zu~8HmQIU}GodvsK{tN2Mh#|G$Q(ml9fu#F+yC2Fkzw%H^++0Qg_9Xv;TF&Z)EUguXj=7?@xr61YS9!^eb+@aH1>b+{p`x4FTOmh^;-#qH&g-*#kXe2^X{7`E(}@BXyG zAH^|_h%v^S&_h+HX?#iDtGS-@60(;S|A^Q>6-W2Z zo5&n*X}a)Tn!K%1g$N-+Jv}|?*16&j$7FB+TfV+= zb$9lZ>LLC0e-{dl@B!K#b9VUtd8Fi@X-75;N%C!Wnd06leFbx>C3=zjhEf2W8x?88 zCs|AJ4<)D7!o6#4Rmt-nhAeYA2Ts@vn4fcB+>B#tEyOrhG-tz&waw~ zn;p#7|F-J8P0AG~`8*~bpUpq83VuMhEfR-`! zIm^V=Jhk-FNjZamG=NfO9!8fT&y)`})C42+W3n0M@L0A5{7F)#*&IJkmZFfeRf=b7QU6>*yD53KwYQjFVo1x#Aoyeh`ot(R zOH28vm}qp{7{`qaK38|w&Bv@2n3=v#^SNBD@|n5CVI`jGy|v0!VB?>(lG|vmPk`*Y zg_6(KWV>!+UT}CLaE`YGN!0!Te1tuwTtHi;q@bQeGT@1^|L@4AEi;4 zc|OPYkTXLou5-YPGZf$`mTBlzDHU;-r7|=-QD1yt$q{fYtV!Z zNqE&ce~%lcu~^Y8r!jjvXL%AfDIqIR5eH#dNM8Aka;{$c07i_((-~Xu4_y@FiMl502wns1z@%l`+~V~74VIai*~;_V z5xDRFJ=sVBKX~I9#Wza_JvO}=4s%N*DAGV_MWtml4T-A8o8E36WU8e}Vn0qxvVKQb zv2g!&`D`_nsSaj>$wlrB1A4{Zit<@oA*l~Ut3x0Iv_SnX(R@P%YJFuI2^xrmyj;GX zT7pWZJ6t|mxq7-T?NAehPT>d+P<^W~udBV-rfnyRZ7^YJ{!p{}>Pkn&CJ_w?D zMnH%Mhj{5Uy=C5RYyECmiZC;UX*DG*f>4%dFLhZU1qI2_r&!M4OQHjl+riXlm#Z6_ z&?yx3K{otha@~-?QWw+=!S~O%DIr08~tPA(hpa3PU$&;>+tQL(S3WAIS4E?vMGePFlUF;oO7J`LY{#ML1CAI z*_Zi28G?QkNl!-Xjap@3umm2^M7*A!5}CR*o)l$^Mao+qp18AjrZq194F52}lXMDp z5O8g1b^%aIUj=T(-zouGctIT6Le5YI)>pg2$(abXXTk5`y0iz3VE%n$l<-T@gcrMI8k z{nuI#*pXlivmH!j9(2&S!3Q;&1^~k}xLQ-!WgIAu&E?_MHt56hU-1WPue9;u(kc|B zpB3`y6k`<7$&%n91%(Xk(4%+ViD;o^kr#(sLI2iUgP6ZGJ8%9b@9+vDgJ)~RVv{!J z=gu_9jCfeUwrO?{xa}yjE5l^E6^gy7lIAabBrDTlqMwe<2^sNpm-%ZU)H1VhV|OJ;P;~RSn3>Yv=d;7owSlJnBbJ*e(#63 zr@i=F6!8|hsoBF?&aHsv&pQDz(Yy4w))VVDt~mR@k6kei0xio-d$u87ozWeCc`nWa z{#U_E`_92EhXu%X6TW8^tMh8s*<*#uTUzP?e@&r~AL)q{iRV)wv}7f!`HirE&!K~X zQjyCwZ-z9q#dsw6)ahyD@$sF{_tz>S4>D&RuPgw=#$TuRhWA8Ln~)1mS1vXUH9>>> zxF8=6f=}=Ga{M4R`W-Vby~0LuZlI1hk5_s~O^=kU!C!f3Y&xA0XZhkHze3Li^StvJ zhtz(fw^u?2IJd$RCkvsd0YqSwLBo%b_m^zlyQ^`*yAjHYE>C7(m;LP){3JuhV2VC* zG`O;*wNa}c4H#-ZkNND22F5UIIyPq#7WHr+v#;I-3%r|m+nWmw6AlO*TGPvQi#i+NN??Wr%!gm;G#a?E&PQlurtt@)= zTYkvV%8j_DAM9W8;-`33Mw}ZwtVn|O0bj2=zN*$UFQ)#S=IWR)j_sLoGi=8Th`@ll z`#X-32w!mM;t=mvI*cxBBkfF8*s#ko3Lqrcv zp9jiqkBrmI>-Np-GK731ei0g(oII9TrV#w|kQ6lBd@DOm5Oqlhqd(|3xB+WTkvWk|L(J~{;L#?>u;wB`FPf1Js; zIh4igq-wuk0iM@*r1*nPmCGR9e$l+$L3|zsZirMWT!PuoM5YMo;w0J=iMzDh=O>d9 zfJ1g7Dm&|vbub4)nhF?XlqPllM+-oGVY$}@6=0#4f|Uc@o7O+NveOsNubbwMRAsSS zW*{pMQC|ohFUWhb>Ne%iF+uzIH?_0zu`Ied{Uze)O1UEzSJyTX7fyKAO7H@{$<9(( z8qNuSyuG75CwvQoM;4I_coRy80o}9e%#diDDoPyY50K36gC$>xAE<-kx>liJVHv-+ z+I)HU<@{pmj{}jAPcV?0iv5AA@VGz9tPceDQ4GuF`?pwP0r!hWk=OodDJy@2!p;#|G(f>q;8lEcJ!Xyo+@W>|O)BwPVwjZwkRK7F^ zM~)tJYc4wk?q2s!nU_pVfH;Jtv}JHli8BkttgkSG+ z{V$#4c!3}k4G5-)pw0Roi1JxzEPihsy^riCg`$D0A!ACdJyLjp34CDBa2-=Hc@6U? z+8yiVigYTVCC=6zQ}N-+7K<<2C!4ZO4-D{%%j2-<^z5kk#)-?&n&8Dc+4spFm*)N! z)``^XH*+?J>1V$@ajOe~GVGMr*5(N@C4?J`{BC|hw?mnKb2~XxT4eiVA%I#WEW)9l zKqTOt>QxvBBaXlGxE|&`(s1*KUCC5}Oc7INqx`8zcFryYt?V-!_<*IAM^U11V@NI0 zZxY0uX-a5{htmWM_NW*l)OVxTlGlBDm_)h0Ezu{YE2t(qAv&f4EJYA0c{#j?(oZ^t zL1o^(O~e!w0DBqiC&~h$oLdi&L>t5~nONtUJb((W%AEPg?-fL+ZJn=G&GG#PL>o=A z|9f4iStbibubSy^SL{NLRG{8riK?X0DM;o0DlO zj@mVhVQ2W8uAVRxgd1vmnd)Y@6XS~n1~T@r(w0%UxzOYLXf`BpPh+~i2UKyhgfgd? z^bu5!qc&`Bm=hn%PJ@^fPn}!_KH65Q*nbI>%&M;L3qxrXxgwyl?h38d+JH9!aS2bg zUIWvm$B%$k=%a({|2?}R*_8P6+GWYKf_oD-b?}2Tn13`gK|siKCuMQ_56}Bm-2Dx7 zSQ@HPHmTObBz+({CFL#4dR}F?Qab~XqJ2Nvm5`z5t!Bg^h0)9LBE7rYmNw%w6a{-4a;Tv!6+8c`dyPE=fSd5>9=}oeGEFO*Xvo_txy=MFffPHWgLY&-U%xd~ zB4?7Cu6I28Jld&Xa@uBO6Ad>xIEO%K8+Au4G_OrjnvCr8814vcJPO>M3jCl)h7#$q zdmz*JwEGWAsxVnvO!N;k+Vgry0-KWbjt&h1s0~rV4OPpk2!P#k^Zw}nphPFY5P_($kfcsWHI6EiZH{wj6L{gVN9&o;LXQt4 z`x;cHLC9@w-axDlg4HyN7*nZ6Sq3S;Om*TsBL{;4k1m~jc;@6*o36X##t;O;tyY={ zP&i!W+SiAqzDY?u6?w(=n89LL56C3^ijCl+&icsNc`83N;H*s#L;x4kgc>?UdeD;_ zq%lU_Sc3y(71!E-!k4kZm%pZHS*dDCx>IYW*QkC$ z8i8JQ4*at)N3T+?e4Y+#rG_alj>urwbw5ba5WD|5pz|`yh@*iLzsVPvo>Gw zo>gRLPus}C^*a?c9oYJcoVrMPbU}q}JekE}`D#z_;O zdanfwk!$7;ECE+6Y2PYKeE`G&0fL7MLX?$=Q-B{grKfLdJi@v`6S-L!%H4^bJP0?F z%b&^7ay+ym)5>)!lIy=8vDB9&+FB?BhK2AvSw>C4s}Kq`yzPBwegiEGFOLB{|c7*{cl%h!TCE z-*Y?x=g%-=qF-b_IXIl^Ll41r(TWU^UPdSg>{OY}Vfb?ch60a9IpjafuQ<$2dp}`3| zWTHI^liIKK#rQv|cYt~(_YTkg4UF;v|Abr}suN4=0o!9vLBXg*G#iyNh|@*Thk&*- z%6 zM8lROA}j?_Y$$+Y8+=%Vup%XL?Ljl=2lJnLO3|J}qEqYOVJ83O z)aaeI%BVBF`{mAPc6B4hMi)RfOmuM`eOP?ESf!cFf^B|Vf1k+i{?Yxo+Fhu@Vs@fe z+91u4hT$iEgyMhSo<@J0> znp&PEq7GYcaSdD7Di|b#TI+Iv3OK+W+B+T$Y4WfG!s=+?!_99q_Av730`MPJ+B_zB zAWqk4+eZ1?%1pZGZ);4xzOTUAD8ANCD1{zy?s9iSk35%CUmvNTn}cvTEOFhtmMV09ObpBUzoG>z9H;;+{`sOKyKt;yu=Uw%RHKUGarJP# zYqQWFu===G8b3EhYf-jihz7Mt(kl@Gy>*UJ_U37ywUNO;}&UA_X1JC=@X5AKZ{K#s3 zvBCld8-O>0xS@v*9$tVBrm}|{m|nHENiT4V0@jBhq}$y6scShwMmB1 zzDocJu|o|Z@gC4g0GskC*s71Saevtf_w~=4|~geCysPD5xa- z14T-Zhsmlnd97+j+u!$JIt|-%1nSz`Bi-yA_nX{2YMzR?DmqNK@D~RsEp^i;>l_!| z*Pq)f|GG_g{&jr@$Y7G_{N&Cg`4FF4lyP?!&kZ9)@R$Y#p^>eGqGQzrO^1)5xYg0F zH5WZ+T3Xirz~zq5HQ|Q&as;-G(j>qmR`#i4?0#OAMzoNuT+iv$F<*ay&EWG*2it@y z(n#no{vl8zS08PBZCPJ)<>;#$S>j$emIIWRN#OVgcBAEw8=L0V|wOK#|s8Ec7t` zA%(Q>a0wFjtDYNWh))(NaHFfJq!iD%+j{okbe5Vnbnk2U zweLExz1+_Ze{>l*cNPdKN(e*fSVCr;+ zt%7J`Zg>Sz0+qpHRjcl6@~5-z?7ONel@9b+{Ya$ZT!!Vp?99l3!jBFoVk!Ey8YB2G z#s6Q(>SGzlbobIDAx$ohH#YQ#NYQ2H9-5zuR)T1plWeGtsYCh|N|zFhAt&eQ9PcA6 zLj&2_nidi}3$Px9L*Q;7x$k^$M~~cn38N&5OPF`Ji5H4_0jY%U-vpISMdb>Fwlcv zE@Y+wjoj*a8{x3~g`f&`j~)(iF41i0pDE;hhb~Qygu`OK9taBvDdy+36+$q(4cO6N z*G@8)$*_pU%4w1h8`+;^0h;f4)EJRB7@iG3+FRQs z5ORy>sUF;?Po8&=2MGN?0LA=e%*LxXiQg_;l}=ltUSS|)T#Y{I`*owX=T?$7oo1OA zruZmJl8P?#Lwp%f#uwZcgnV!}nj@Bwt_Hc|$C3u7i9*SfcM32EEn8XzKbUM56S9U2 z{uwPX&XsP=7$bzdwm-5)^=^^-S zs+X7iLYMHC+`$9f+v8}s{Tj!9x4ICmG{>9*lKB4Ym*CP-`o>ms0!cN+9B+Mt#X(M# zW0V+i78#i@0*eOS@t?TuH}}6R*1n|Mp@+(`WK$wb6cy9dGD8-4D)-iJJ)Cbwfcuk` zNiIfhQ~3)5H)OG=XCER?50^1sc@Fjx+|gW-?ShmxEPYH5L~0pnC=_u zDxD5VZCNqygQD3{-iU{9pRBKtk9MtA_ak7Dc)gFQieo;5{~h*#65m0#@``VgS6_UM zWT{N>ROwTAeRkmiExzUT{(TM1uCu2izSGx3!S_9ZjhTA`Nft>G^%PTSe6Y96Of4Wz#f`ILEjvc{#@#I#@M>h8e-+yqw}dWKX2SHIehu}%h0&ju!Pn0#mWsjRGOyP#@EucTkBjss2hz#&J(S(UQr#d`AO%lPzr2*B{2wOzARb?ocO7qWZ1pKb-M zwF5e(d_C$fbl+Z47Ux#y`U$HYOb`F^Jv~3`dhKZf-5pt7m)ZSvt$*rs6Ni9c4cy5DSnRUP|Bfuuyz-cxLhNSGRG~gDB!O6aM4gtm|=g z9VegMZrh|e);v`2sJSbRVtiuxvGNn#e!cAi!yPIAz`!omf4pD+eb?~nc~?I+5^hoC zpjYQqZ2~Qy-xU^6)z{W0J3ZD0|C0euD^iBUKTE3xXU5Bm5gBmCb;3Jk6l|86MVLv! zNQmU*=SNB*;n0cW4*pwj49nd@PiE2oxwABpIIgIo;sQJtNqWET?zr_=b2Un5OBRk|` z>U<9zOBRkh8ZNZ~d(rH!t}afh0(};jn-Q{52R2Y~_R%Okzz7TL&ZT!YDQVJ%mhOhj zEy+8x7T;Iy#IiO48i)8|uocQSU7len+LIqaMTkZtA^xJ~v^-Wo*G56|Ym=KR1FL1H zG+JoMi?Q1)a;a=#?x;nDw-qbAxEx6x&0qisS<$zSEWy~w6lz-Pd71M=5DgUc={Mxqg!W9uFa%B z@c&Wu)V4Em`!;S4}QOSVMNAa3=<}5+m#OGVgWN)Ty z1%f(z>huNMjzt~pmPR}}ZvE_=tp&*8(;++zN9(TWgKh>J;qN(R5#hq!zZ>;`nUO!P zKc00QAp`CMjxYAAj*r&WKAVH+5cFq$A(DrqC%bVz_MePXPLz;ruWVrC*r9^$Cuhhe zpL;*xQGV3+`tIvxeJf7)%1w&)X@$eR2)lz$-$jMq)$QR!07%L`+mtzWa(uDp7d@tz z<#5aXY)v>!ISt^!?^fw}jS57^MgI&~ruILn$#Gigl!o43Bd$-h+rzR(6Gkn7K{W(0 zm(JU->IK|bZs2%9ANvs3eK>Ep`99{C)g%=|eS;8E=Zr;6{nuT<=?A(n&%?G$&#SI* z>%;A}nO~-@C%aXwfDkM^;PG|iX8pVqFZtHUcLXBfPPYA0ZP{|tHfwulcP(;L8+bdO z_rZ{+5Nk61HfKhUMK9(u2S`-%zkS-T$4+V097z?jFf(VbS7<^4g9Arc>YzzLxFT;E zu5^%kLbO;sTBRr`5=wXlBr*k@^VZqKNZn62WHeau)Y(wg#A~K-{NDp@jy0Bkz?2|C z5TO98J$YGL&(Oz>EqfP+J%i;-FkFp=CUx-UJ%hzd>6Nmva2hPP^r*sszxwSrF^_>$ zLRIFIMJlb$)=5f*{J3Vs>J?M7jmPFE*Ww<4Q2B45*V8)eb1+qlI_Bqm8U=|Q#WZ@X zg)jKS^_sb%lHkdIJA1+_$vWrfJ={F+0}rPLn#rks&v;5xu%-MjbkUYAooyls-1p56 z+wX^N&Djof4{v+b-y5kB5C8$F1QIu7!&>@%BO4+3U|!7?0=B1E7Jlhztr#k1toX8M z%WzwMth=xEpA&%GophHTl!)sQVI3qTsaTcA^&%U4CBpPxtVQ2%3j1%{t$ksLwxHeG z%s+Y_-o@W}H6xEW)gI!K!(SOzyXcyRjM8jmjYf%mxr_?v#8= zv?2>TiS6f!Rej^PpCIpf<`OqKJuXf7^wW?zFs>}J{<*)KayKaS7$O`wbDd@IPJJLE zsaV+Qgt*@P1^5MTsu?JY(!Mo8YYArastt#k8sNZidB+yd-q$wf?W zgbyRmgnNs%Dy*JYG+T!7yGGXRZoChwdU*x)kS0`@K?CXugw-UIL>*M}fMk)uLZ8&~ z|2cN~i;oFegu(I^ptY++@o-QfrN!6n_{Xa*@E~P_ZL&xj9;9RPC zy0>&NY}V@c!8+`+Tw%m$%7Kx8S5$ti=y1gZiXejP>ZF_6ScJi@qr@-&(2|gl0MLi^ zqAZ7AH;J43rOS7r55Er!Ta6g*CFA_|Ot`Y85Z@jA*eL}^Uxq#z@^CZ?=9sB_;#x6n z^Y3NYpqU?8xwnS(Wzvd20@kEVhQtc`%AuloBN4J5k0QU;z|eU*IMGAMxK=#o&du>% zS^^Pb`02SzyDAR?y7&+h!zGiJ8Ch8c@sZ=>>h*TB-9T10;4hh<1!5XUA>WIkqP<(Adg;(i zv|N@Go7@RVL1cHos4%g0m`1g8nVjtj2YtiYOyUJZu0aQ#P75y`K*P`uMXtNNf~_~> zHZR&(mHU&FQzVak5Z%7SOSGuV0XTxX-)$4j|759v;Pg~yxRjluFHpLqF*MOKlqH{Q z5ni<9X5`=f`&|&?oxj%QueaI)058JQ@NrV{DDOb~GfY#*%^6dgS}@K`jU}nJk(WrC zkrQJ>`wl1I_6i3R>vC&pA5OZ7zblAvSj-3|#6mV2#8qUi7yvD6$2AghJlt`n?E7~( zKuL7Kk?KixZv0Cj+%B8GNq%%<0cG2V-%3%Sl2`UCzW@yCU(b2HZP%7u0nE#Ni`%W3 z-oWs~sz|t3#)MMfr!yakkQh3)6OdG_BJXGu48P;1tRu4EnbcXt>pT(ucU(B1nV;Hf znE%x!$;B{KO3$UjWPR4=PwEI9hn339#lF|~s{vbin1`ETlnxdalVI<*_5@L5!dqc1 zZU24`jvt2Z!msk1i^-D>_yom!V~|E_E{%f=O_L1wP#zU$s{XLB#*5~xv6sJdBxG%@ zkc1>Y7f*KW*nr@&$}#L93n2$U?w8HS95;D*sdz%HA3jF#eDB2@$wv

6*CXg~! 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ΠFk~=8!n7;_iF_iJgL=7q zF#&(%hZ1faE-|j2*=u~WogG>m&@W4KAAnp5oEbbVz63V|aC*ML+#Vu>F?=5_?^-#9 zFaa5>wq5fD$mjt8)aK9cjMp~$`1&DYW8f&y+}Sl~4c zu%3nhFL%13`-T~?i1?43esb2CzzeZyT>g)I*5OJD!5(g)8s^odW<+O9wzR21^9EK0 zNx%^q9RLHHnY+hm+0ElFv&*V@E^XTuNonuymcpaV*a=?*v-|cou@;cmx%9_fnhaI;U5Tg&LvQ>MTo*~0OSunXu%kH#ZG{rjLuE|J(v>%Z{kjeJtNHsHz~ z&=3RupBd2=Hp;Z4tJS%*IJMV8v`7VSr!f$AzIhqRFaZ<^I+~*g8PT7`rKUH>T%|@h zwgN?k7Dt6^xry4O<@Qb1PARELd4xVj^k}df;S{~K>a?4cQercyY5Ck{@l>Op9(I32 z#*fp^i*$uK6~ze5un6MXh1^CTZ~Cty42ERM8h;+X^uYYd$EA8xQQ=V`pG$n$Ev1Q#4ZJEQ7M5D&9P1U8+Q>sq zMT~N~?@z{PVp7tteGyp4%RXoYGzEZ0tY;tr8vdtMzS!VKbhO}f;2G4YugOBd-g@wr zy=51d-?24vE8$&jdoCAe_x!kihEYSbUS;p%5TlN<8`hZ*#II%lUpX+V#=aXPv9#(N zh&Axp)3RTxjb)4;s!J9;1=OKM|0(I?R&xQ3nVG#08t6U!_kuu4hUvl|!wSQuiDDd3 zv5s=xL;jC1HD8fG0jVJTWmRSf$gDAqRO<|_i$QkjUDwovz+_KXF-(+ z*US0Y#aSIzqaFfBS9gqUc&c)S@*OJMLc9lHzmx_>0zN4fzkclkh9Uf}mzIs)5jy}uZsH%RJb^)EWDCyKO`@SAqUJ@#!7lh^`^Rf6LymtUcEIMd z|3LvI4dy3q3}Q^YBs`=lR{1Vf4PQaFwjF>FdSml8K86dxPZMha&i&>!DJDcx(b0DI z=N!W&Ym(-##$B$alFHl5h>pqH#a6sg3Pqo)+~>I>V?(H!8#3kFix%{i?rM?&-PGTY z?Tx7%K<=On+vTU$ZWU9W!)j(KDi94;^#v!O>oe8(#TgCM=sDrc#fYmD01lMoOGDF7 z?!JCXK6kz&c6g4g9{XyZ@d>y)MW@=K zt?g)gB|_I1stiW{d@j$&%yq4>0*o>0mFoCHE+yXp99n^7!@7jY-ZcmWE`0%rb)#v|3(%w5}2POboI&_-d5`V-MBjef)Ici*7Uj!*$xu?5_`{5NQIfg;xfx~2 zS{zzmFcqqGgRmy^JAl~BQ=(ks()Wnri8GVe$7iENQ!ftQ!^r-K(* z%UrV(C<-?YX=OK@-4LujUmuuJzVUr4}7NKM?c*&*&Lc=Td($BAcP%LmqidV^vVH zwU5W_(61{11=&=c{L!n@D4hp*OoY{p+n%EcHGh81dNEBb&)1u@AL!b)ew;GwwgYP{ zE&OQ(kAtD(e!HcPtNRJHWEu_dZm)Li?CyRsSF4)qL&QZ080%~pU?TJMYI35~eK^BR z+5^F!J1nvjI3rxI5iC-1RBNEmEaKe{Hy(@esE>CY6muUSYTCnF!7bHjyKz0d+-}m9 z+D(UzH5R*AFkMHu#iN?`m$e9#NgKXVH=3~00+*OF302D9fOK2ApMNNv5h@zkV`ynEdqC<>*E~xa979GM-WjEyOBgKD>zDt*(w=L~iAr z7Edv4skLCt(YrD|(-OEY=AG%51_hxl1Fw}@$?M@6gv`^@%94cmeXi;NM3a&@cg==} zOK8{+fN$Mdw3W`4`#b_+LP+Z45dJmKc#g%})r`@gQ?fkdga`t9`I%!44id<6Zfzgs=3$Zq8x$auA zA>;XaLLv$1>O~7=#-`zZny5<-T(bJqiLGkKYmLbpBhJBx+YGwt1%>ep3d_sW{Z6pR z&<)0rjN1)=hTRWj2Mw-mbY^WloNzd=$cn{LBC)dZDdmFr>M`bwpITTYBiC{#t)o|i zOBk;+zSIED{r_$p0Bhm1TG1$}B++p)Yf`EDu&LDj2lx2Cu~>OXn7zuelpCJz(?86h61{C?NB+%EmLi^`r6k?0j+{D#IO>^ z=jE0%v^*N5*d_U!0+lOrmWp6+OaWIKZFb{B98M?|CTj0*GIw*`=|p*tSIZt7A1pr# z0)25LnU-mrrbX`yLdTXv%iCk0%=u~DJSA2gpNVxS*lh50^b1!PrX4p*?x4w%1EGUCUK`lwBAWp=HsuDAbET(;@=Bs2=N!g zOzSUy$eLeT1>9bqd}>*@rUr91L%vgd-ROj>`AnP-aq49uoCC%}obX~AK;sXnx~8|W zhl?{D1DS$Z>ee}$RJF@k+SEZQ$GQ6LaxBB6SG|9v4Iw#Z-=EYwm!r%IyOSFb!N`ru z^HvBlu6mX9Hi?_^y7WxG;8G2jAKI14KJTgRab!W7rJ3irEM~VNG-?{*A0j{0r4u=C zFRFE3?{QpKItBh%${=B1uFWWC@A?JQ5aDVv@7l;@T6u$2OmtfTu;gk>-LcOl+Udio z=+mBYKsfNn0fxf(Nz=wi&_myAFB|1OYJ(m!Q}-QRs~lSIZxJt(e^T|_+%v}XaC6JF z3vu!B1>u{IUY%sdy_B!RIn`%YklMgCQlMy0ExZ@oA6VIwkdbk)$guY_I&`PaLMokb(@N0q0(w8FSx&?oaX=uu zQcZbB!Y2>jf4pV|9@=@AX==wN1?@7O)`KsCC}PvJ)Cyz!-^&9zDgFW*^i+5Z0ZC#~ zLJhlZJwPdj`bF%~VZ2MKUydo?L~Z;) zTpL1o)cvju^GA+`YbqQyXiya^Re*=aY?f1)U#7g_GlMc<4`@0o-M((&iOe^79#E1I zn)#ik#rKJ(pu(UdHHv^G2CDJNq>B<}Hv|Zgu^<0a_XUodlfN`^s!N-e3B#!nLkt+= zmf8bQbPPP`R+^kj)a{)2ubJMG3-?Fi4GICs7@+8|_l~w;2XC|tzh1pCHRZ~GBa9Ge zEzP9g^+Z`8UR+IUVMY(7q8g1kQ`6JVtL~mV$;4=#!!b$nRj>?mtszGWF+@H5(?1SI zj5XEHXJi&N4l!&_?eNyti!dA#(w4B(TBk&>ya<3?GY|@aG)5>=)By)2X|PfjzspYB z`ri~CV}(4|qa@sc60P!@W=_Zz4VaQ*-Z0&hH3Zfr+n zIa=;5dxV(=f2Kj-5sF@M$Oj=)`%b?dur>hHgZKqGQ^t#4 z<9v!0wi9rqMWMLP*XRL<5w|#beIOG59^co@lvQ1e~wCVLa*R{XDA}&{{ z2VWG){7xNoq&C;+C^uD&F=pIveiT8L8n(z@4o z>=S{sa)WjO7q7Z69C@>I@aL7sw?+1{zfS}I_{Bpypr<_c>Fw--F5=Lq#XT+|{u&fP z!P`-C4sEopxKAK?&2q9FkA$>2Ho8rOEPxV-kA6t9WQjXi6jZ%{_iwlGOZ7pkMA{lr zun5O*%`!l}$!nl*G}WW~RO(k|&pB2HHE+8OII?iP>Mg|nc428-sdSKpEF zg0-+y#yj$<9QtV4E?vES8;`4XL_ep)RLC$~`#y}lr_GOI!RC-3J6RnVmcP*y%pYay zPEy|f=D>8*#TPQwGymg&8X= zD=^VcF_)|pQ^k~hPKibfI~T1dWUSXcV8-iyci-v5UKx`%dvz|_rD*6by&va+YR}cS zL~=L6aV{8#=DX{s?(3aO=Zf(Kat9h1l5fgw6GR%pA6frfrSINC3reCd1q~Z46_j9k zvsb*16l&Y%gZlp+&Q%z9g{-9=Tf+V*=r%ZZF#SZ?x0-O-UgUa9;U7ZzeEuDvOLd6A z>Nw~2<1kwp)GQ#!VU1X(EIeEN(qAC=d{WO+5(iW2wETWX^!{lctxBA=z&x|6dSUsaUoGT<$ zc_rx^C{d&>kY%dOPKtzTy4M<~HJGoYQ;*{vqLNUw*W&hKaY*)1DbGfj8#6{|Ayq3= z!M)ScA-=PjK(j9tfcJ}^M_i@6B~lX^D2t7WsggjCEX7wt+i$_=inv#H#7$Eg z%)W5-mAbVlzz!zgXq#!`s$xvoc|q+z+l2ANwI~oF`4k85#^LqQwx$b0OCzh~BNMPU zH+PP-tLlhrG72KU3q11^IiLLW-rJEw)<{rJv#Q4OS?^EFr7gd)J6CKEHS?UXI(lez z=y#RG{^HN;cT@aGy==Dc2qhMCQ?}_gKS1hg6<1Fz5sS<#+LG9D64{5`=dd}h!Z%ow z`rhbX*OrY^Xb_WBPs?;_nUhT40o<84!TD&vK98~I*Rh%b&7$`25({Uj<5u1;wx#hZ zeKAPi$pbdXeeohvU`yVQ4o_4j3vuMD*QZ{tH(6C?qZ8TpYRFMma3u_BgLmIKx*}aF zX1l`PNhK4I6k8)bsj8EcZw+Lvj}}+1_-qf}xk0moM%OkT`E&038N4A5O-ZqFs-<)1 zqVb*#d8FZ+4~4qQne>FeOhlT&fOA@+a*9*ygVYEADEx?}!+s_V1%>w??-3v(4@h^< z=VF;B`~vMex=5kX+h>YAR_Wpeo~A z?E1-2kbaMHJa)7|vR2q!qEs07jqi!|PWZf}6Qf;A| znOV4AU+(K1Z?;>iMile=RP-;r6t!rt?VL9wmurAmT*Dh(?eX-h9rdOj)_-Y)`(tM* ztTpT*Ua9wu-|OMZr%|OeUK1v{#JnLKJtgpvvSUJIM56}n(KDZEp6T{dUrb*;+TrNYK|EQ>`^#y-NJkrEpGott%eri0TKJ<@WaoJr5z# z^S%CegGIFHih4el0mYrkNZRC7_UW2=<1m`AZam!RP$|?8epNvio06SRMI2X)1@Y(M z8&7P1{1&hj6=Qb%rp-yLmD=X$(Gk6|?kp{Ibr&9vq_S#xxjf`Lodn3n_Z|KaFe_YC zIxWgQv~^k8bH8%)GXRH;!16V`HIN8lrbqW57?2?*BePh0ylICvu4H5h4Qj-T_XwQ5 z@W+eZA~C!r-+};%V=$CQM7Vd}VMVvjmXFBL{T&&<;n?|PZYjgi75AyQ0#E2rN{8KY zcHD)#Zcv7PWOF8PnolYtFox-}-c)mP+*Ea}Dpw`(-Uep0Nn6-@t!5L=V*7{PY}t&; z5HA@t6)2ak-cpg0aHxH5&?^9}xVG#-57I~o6#Mc&4FJeMw0j?L0s?Ij>HVxNUqrmAN3SL+1WE*`S*WGyf3U+|DN#K~SHsblgyo5y{iT-5!tw=LZ*kO8X=q7sgx>yX> zzvF*0@fz>h3CgH&7=mCKO9K zC+KlZ4D1zg0$bpKrlxjAVp4L3m=6;mFfsmX0%}_I+u8*7+#y!Wa<%Y~ z9%@3OdU*(2QPI9ziWL)({Gv~(hh81P;4=_W*!zb93B!|%=gqCt_qP$UEt5o4hU=2& zr}Hg5J%%Ti5!u?9$cZbl-%^JIRugdVBc~sO!dF0jh^bf{p@|J!g zma@BKl|@A@7=mjSF*9}aBr%KnS3JVB?;c4e`J~P6{=&y9D4o+BC=s zJN(MgCh!p`975U%cP&fIRP-%WtNjm>l7=_J;Pani;GP;|)U)d>v#TOZ){o_MIULbGqOOMr%%b`Kq( z_j2YhIRebeSU{lt$7dJW`%{XH#ECf5478m-n6uh9Ik{2m+vf}Ttq*qrA@kh>c**^5 zbuUHL+ou-Drw5Xns-=4~vu#@0q!gR(FMlP7naLRUQwS4{JsAywS4AcVaJB*_@xS=t zy2L_fF=sGE<*NNk0mW*^8OsT<$bUhmma|USe`#9=mF#`lyJt9&_`_i|z(_h$mcjzq zxiH^i)>__>78mOP^Pi*dN^~eMPe*pRx`juu8IK4=&U39-@k>N+xIEnC&c(4sypgb; zoqN?R#t8WfBc{?jAIKS@cH%yQvj1r9o^~VAV=>~~T>#w{WTWN+{)QGroitFf6xU&sN+#P404IYrRcVEq_6vTK{+S-O*OFSa@`hRz8WR! zw|&2lZ{1m&@5)gndbD*>w>^K*Mq!~|*IV$3irAz#x0@%l{Rmvbz^O0RD^KelqAN?) z$xXg~W8krT!fmr`&q`;B$ACI?^{eRNVLIq&H#bEuTaIOUyog(R`9WSw?Pp2UVak{r zjYUJ$Z(T68pRZfZ=12#{pfh@yd{2ah(PHA#4E;}LrNl&P)`Q2?wHkBf(*ue=czVT! zD)?klbAh3OVd0QJyd+0w_3PegI24}=@1!}PHT?r)Va9B>$T=i?5?xcoVJa(P;jFG zRMvXd@$r}2X#lLPYh&Y%>|6Cy(Pq4z#zN7_)Rd^!Y6Dr^E$ymh-G-V1pdd+m#V zjm_D7B|`Q`$eF6-AepQ zH?wgsk3+nFQ0!5S)Q&iQP;mfHrhqFAFcg(2gTK1DB~4j>PAv{3GGx|FcN@9tWk{#D ztJ9tjIUjCuxu^xR?>d+Jlrea-^$Ja^`g|z-{DZF{KkI^UZS_k#UW#>@>+n~8Goh>+ z*0forK6|Hy4I_4+^B$BIDA>b2@g zcDMctNBJ;`a^Ej2)~iF|8#(2STD*0^5rk~U_Fy6hE;0(oU@C*&Vfz!rU(a_f<$vWR zy|_$U8!I=uVPYde`Bxl>tj|{|b@9Fb^8(ZxjAfjhsV(rS zGms}l@!#mHr}^678wZd%Yonh)fEsCw(DDBEZc)Ig*`x&*;N7)n4o1*C?QknSAmZje@* zAteRrt^sN3&Viw&8M-^~`<->qx$E-xtXXT=?|z^C{A%AW#bCX~uY<}}N6z}RdoSIJ zM$^o$_}|GtvRDGzxqREoD}vna2T_H0%GBzgq>Nhl ztl*1wz68W+q9?~Or&BU*J({%F%n=*+ckN`Nqi;qjas`4`zWMO4&m6DW*x5L&c3~=I z33iWMd=AgnluA@3&c@2Y#V$-4qd?KLn0ysFKkF||sHz_o2!oY;%ucDrj&m=UFq{iY zk^#Q1GJa=~BB(DRCA$h`#)tTZn!HmTE6nZkwU{ETGuLAf`lk~J^CXkMN2PZ%s0 zmgJ z(daMu79HLe#JomL)h|F`H~;=R17;<%gXW0agQhGQT5oCxtGv#@iE5Fb4rg1A<&6hk zN``)(81iznsd)XTL!=Ga)im=*Pd}AGLmThH@gyUz3+wJe3VH+uwEKVI3B1o=hRN$ zeTsQyP67pq0rs+Kek^}e|-`{F`;VSj9f=`6*BLFj(0o@RUECU@Hx}% zIK`d-qm%$vke#Kt?_nf2fM4s-CuR)F6DwR3ORdfA5AC#JN zru`;V%*-1?Isg4k{Cuv?grA(#9X(T%VW+$*g#nSmawU%cNl^(<^y$f)6X)%QoFYf1q6VjPB3oV zh&?!C+d~uYf?Y;-`g^95f#eEZ`T4rNQM?(U8OsK(%KEm^e-BSjuhScgnaBo}%DzWX z27~0dd!uPqy7?CW(l%Ug=y|V2r8nO}!pF&f7<;3>D^HQagy+0%_hf@xoMV2wbQp2x z=&;YE+$=g;`+DVk_&4VPj#K`Y)0Z-e0)i=Xc*;0)RS}dC)k&r@Zv1X8FH0-XVbe>0 zBkUUzYnnc!yXJasYB)4&C@0H@cG6w{`o+YROHAiFJ34HuAn9(aUzI-U!&QL!K|4TJ z%ew!>vH*2z(z#Mt3~MaDE3I|@_DME?rwm2P$s}W)8=F$;@E%>#1*XE5%nh$MVRjXl zu|QlsN$Vcafd=w$hpv*FTBWAWK4faX2uf8?9*i~FCz1*|GvJxI_ZrEas z%1tD2562FO9p;x;B5C8_#oiY-Yn%2x!+f8N{itP^_e^I^O@6vR75W9-SXsSX{BfwM z)(G_+;S=8Q7+JW9jrJ@fUq4SlT`Zn^e?-yL_Dx{miU%Y$FCn6#J||3je2el2#HoNI zbY}LCz;gTmenIuuvL@%Lx=>@zUrgvjmM<6KZ-Rdn4}82p?hT0#H>*rVKi2h>4l`l9 zI0Tt>ztNLtNSWHq4sp2SwnfnA88uhUM#){tvUR*u2v_Gy_ZDMJ%?EpOZh1M?2>&jl z+Pr-k`R;Af;EVUbGjO-?{z2YvJL}Q^uEhV|-s5afyTcA&LKbgi|0JUAOo^A5_sX=s zCG)pT3@0V=qBq``9}~xi4~oogby@1VayhO;kfpEfI^B6~f|U5Atml1p zg{0Fl)kpC9TtD3Y*@ss=U#_@&@Bj1Ae^58Y#x5=-;qO7`)2u+S)Z@Fo@ikp>)7LLg zDPn}r2=K+uo}flDOsi7Vrg5{b7xbz34r}V01~q|P!c){pwar)3h!=y^Xx7j&zLx`) zT9Al$hZves;&kVsWRe))bK?=w z2Xa@$8<*7|pXa&Aar)7pC!KooS(Ep78gWZAZ+iQ1NXG`*K;&0B;!RfUs`#Fl&2q}BsS^=re{gvHu@fwmHCBOyXtrVgpr_QD0TMlQ*?L%5kUX~nF=L)hGp z0K<>}-#=2DAVt2RZQxL?tp5m~ZhLNugXLaWLe8$pinAb*qcScK$ zk8>KXkcHeIZp(!ns31C3*(BimbKy#X2s54t$_hRT(X6})1wKB`9uBdYL!0X3nO+q- z3L5K{Kx|ZB_){)|F^@$;lKqr#G_vJ*s1iMPXjmU9td{L+n`l8RME{}aZB{ir4Rq>WnFkc0Bx zr>C>c-eNx*kG0Wt)*K2!#{Q4r=EctFL_KZ~IhVvR>fEy|(l-T!(sXfNK9A%{NMtOU z@FeScFd6yxAgZBJ(^Av9%`$ovXkD=uN@Z_!yY(5}GukP7!$&FUYp%1Il#)IlzjfdX zfpaDF#nGsXEl19=3M}t4kMd>KAd|lu(+0g7)2$A+$f4spBq#9duB-1AabN6DruB*q z3VKd+Gmz|gR@EDLqjF0lDcoLLcAV5umsdr)FxN4ylUgUG6+!eyGUYSu9g{>$NUSV% zj{sqroSNZ=3Qm}fy}k3^3@6aR{JwX@YugEfBk3zM{c5shcc#WF9rL%JRP4)m$gNfG zWfWsjPlFR=_iw3oi@VSXV{<87^*!euwa#Sbx4lfPEN>HF+=GqRO{{|i5)+demUK~u z@o|ypB~4!hLF46{cW5r#nXcMy#p{AA+QTiFVtkbQ^+?Uv6xKo~FFiWQT4_ks=j+J7 zI0qaH^vueW^t*ZN+bSR#Y$S9C_l)q5+!jE?9PKoFPb_gP6#KdIakne-Yuu$(b0rKb zCNOzjlCid!({qo$rq>^O!4AkCjlX=*`ecf4u?IqOZOc-P6}f9@gcj5In3U);YztC( zC&ovQ$>hA!=qsEML^VUocwF^ACnr|eV@@Z=!Wzr1B&}4aDl&MiZEA_1x07N^FvC9L z**fHODLzp)d7%hOE`1gpOwcN7IXqDspX(fYjou+`nE3xT{zJPWVq+!~t)8nCX2 z;MqyD5eMaOqA6|Iw8mdo*&=?xc-ed&=9lu`XXUi{()UmXO8brBN$zTip=Zj{72I%b zy@&9F(ZP~6qHW(EWcSK0DqBA->U766(78^nfgT*`fXs0XR4-Oj z4^j7{d0!YF7YqRl%q;EqDFkcY+&TIB)^WnnmEVDSbW)2=?AYEl_nOPbb%*#NJ|^9j z{?0BQIB+z9tJS)=A!Sx1l}hGW)mgBURNb2S=rtIjE}-6r!i!*+{zyu_xbG-PIMFt+PP1Z)s4 zQv#Kcu6@=_#{)|6};c_`h_-LbIj5lgY zod71KeVny)DO&#L4l<(WjC=jdh+JKoS{;5EJg+m^SkNVnd)R+#dpxf^S{ z`#(50U$#8{bZ^_`^W3iYrCK@_S?W|=asy&hvMj1feKNFCP0~-93nz#>pXyw$*T}>~ z1o)ZH00;^i_%2f3(!TRW2b0e)Ort;vH5~L@C}go#OJ?RLS;^~dcGgao!Vw)EQ=gNZ zFTiCSQJ2l946~w5SAUVFo?f!|j5*MDS{GZK`PB|OT8F1A$r+TxEM3e!@#V`CeO zV|6^aCZ`HLR)2T+Sk@j%OY!`R$y&3i3T4N2CqcIm3ao^%+BO~iQaaa7J3e!7Nu{vu zh=k(&`tiLuk2uhW-;8_K=x}fCp{i6W`1YK44wQTSMK5Sily8BmaQS#V)fx+&D zlJ>Edq?Ch_+6(x5B)ue|ZLL8l*^VVo2EJf;u>p}}PP!yHQM5J&A0%)XUc^~OH|!L; zhADxuS>vl$OBS}K=&?_qZn=`aWb*+%5%e8dQeUoO?{>`H6QIHUETtb^pfkmTh{h2 zN|aDJkB40^-cNKY^i8pm@<=tuhy7;#J2~>gC!nP59`vQly86@Q`^#hhmbKSfdCkmr zzFVXJ4rm?^#U4GQsYN>cAI0v;Ndv|(wUfrQBo`+^&;drVhtGZwDF0}{3|ixJJ7~8l zdyM?rC2 z5x}yCX?^$Cn);{DT5mSO{+v4d{}sCnd;E56){*si>K~wMc)A!Fo?fj7+Z2E>Q(E60 z!u`%lfyXZJe-JzBc1ncnZTI@1icg1!mP-Jc{?QA+I2&Ebd2$xM~`;Z6UNq1+vR`saqhAo|qgf zZ)Mb3i3jD8<8k(=u#xG9*{S1{ITLr%=@cXkhAh1?;R*T)!sMbIB9D3OtBjyRnXGx^b;4+Ndqv7*eOWAC(@fFzA1?Z z1usvE|J1Q{kpqi7ttM4Ve64+s1+Qq0Q-zU8=BjeLhG4?kA0D(6t|)z(T&Dh6`^&ns2z@5t|;@;$cvJ%2ynE%*S=Tm2xaaBK<&=+PMXhZ z$kR2u{;{Q0P7n058Qu{sJryY%xqedMk%oK_O*3+g?)@t$3CB6-v7OJ;>UAEN<5^_L z5JFAe8ZnNZq>r1e(!MV)Sz7kp;A4C3su7^gd4^aSo|!3S zyRKHu1KtL9vW#$ORK0Q1AOkxS|FLDF61fG1;yz|6&qGW0bIypmFGV0hxqy5%amADu z`#0{c60ne;>P=2>{toyF%wMh#k0Sb`n*mc&L%zJ2hR*MJ;s9l=sPZr?V>s^!mLQDV zw7M#UAaJoJW_)ruJ5wJ;J!P^IG^h}f(5jl7X6zDG&&628$f*$mO;Zv2{ewycnv@L- zb`rg8$${LC7Fbc>k*--$8Gw5-pRknmM~J5wpM$vk3~oNzD&OR(_I(_>9Ld^!I2bKp z+=V8^Z#+-e9sA_HuXFz$pN^~66)`+_V~QejROFxDeVuhY7Y-UO*ETDIZ>a-qUVY4K zuT1XrHw$>-?a5QnohANzu<@>!Sp{PtSKOW_Q7 zu2g%^$SdjiqWZMP$D4vbPbNMg>d<#tHCvWn+#SU{Xt&-aRvdZPFO57rh>}*0(8f1H zfwa$m;+)iugYI{ZJIIs2i|!}ZZ8wJ=kGD&sxO@wL=l@-}88`y44`5l*mTt&GjJ#}k zyk|h;mrs=?8_K8e zAG_Zll`lQm()g_#8{FRTIh?ZC(G5D|T;YTiT*e`Q%Q<7f&AixkyqI~Jxxag|p%+T% z>7R|nie=zV0%8fblYS>b;I4T~yg(z;YF?_nW-{6I*z|3rwK$MX{v}*J_)LnzZCFwR zyIhS0Ilqn9rYUtvbFo4?enYx6%{BAQTt(oXmce(u4f)_HyMmhYIg*AXZRm4I)}HmC zUff$s#aNOl&a1Ga)HO&pi(ia*CPJ12hgDp`!=E#(gBp=>-#GBC%CgAd#=k9^t9~dE zrWT*z|H%f;Ce$k`wXygfC6&TgCRrHk zF6Pmpjw6jDEm~BM^`SzC@!Re*UyLkcP69Bpe5OzpeOjva8lO?^#N?xz#w1+R$~D!? zoO{TlPH`V$m4WMR@!%KU{(Z$`wKJ_WYr{76U14&akQijwE(xI>22DE<4fcmImCeqG z2L5&b5y^Yd7f3qk076zD;81}7YSB3egDYgfC zyqfAaAvlMhX;V;qq&}z;CBks=Xc#PNSkd4vhs^Q(XNkwC_fn^Q>n@)_Yt3-fdoS=a z`C_;`9fhR+boM3LK($$w9_*2BSK(lMt>II}fBYD=vB=i?ZYwfx?=_zA9}eHcBa`Jy zPTBAR(j=@&gGL6KU}{S+qC|; z`9TK}sLoI4_)NWaP*8bcPP)vX$+^`8)ZD|)#>@PzM}?hqargYIF36b9w!XY6Qy$#? z^@BVHhI5mmt>6abRWUltVS<|&+L;U+6qm0ZZt{STyu7Bq)wRfLK>lHdVdcdaD zH7r~9EuhbfhGD@VMc+f7kzoxV~*hd{^@ijWRy#kw*;8>x-}0AyE1+?{h(*zx_mv zzB@V?>gQ;&=*8!EpJpbCT`d$alLjImr;Ee2CTX}+d7^cXZa=Kb+$FW zHW7Ga2K9H3>Glbj1WPc@)iDe@hqsT#|B}TpHHWBF0qAX zmV-^Py2#FHKxk9j&PE+=zkDEQuCtY_RIILUkPd7jl_mB+O|3g#A5IzZ+HLZ+PA$%5 zPS%>wNtAf0+6s3L{>`Xd)!>_3;`d4-HlIRpn8Q_3mru4#MSPanx{HrF4oRslixK@{ zsmhysM9J+S8V;8L1?BTBR$1**B6u^RW(8!_runs8%R;CB_%%C3BWsPHx4WRZh@2^G z2b*wg?X`UF$BsymqzYg!Y#h&F&Glzf)c1@y)9Fjl4Cc8uBF{9O*XR2;mqCs7`R2xY zGOMkTwJ8d_h*)d)R(QTq=nIB;Dv6orX3XLot8MMN^rbwGAOw+6%GCHUZkNxkcN%fM zFs}wj->o;vPt&Cq@q@7{w)XR7(oPWsjJwUgpNqM*Z{JzkaSpVH|>{bmyvTo8)Fcgy$9xAp#M>R9E? zH_V}(#+Nk@B46bYAa%}j>s4T~VfK0fa3M4zUV2WlYP9+ElL3Y)LJ_L46^~D%3%(?|`}vn|;t|K|89l||@GklHWxF)rmg>0NzS=3fwMN2pT1 zX7y9VSpIP_#5&sEKr(Bx!9OP0E=aYL+N`05DPDXZx#GZ;4S=Z;PrKg$Q{q8Yls>o| zag4E|^aj3Zb_`4X@6SdTYcL&(O6TIuiazS*nVf!CWMUpD^4dvGH%i z)`UT_b9dB-WXIC-d-e`}U-!er+0L;A(99-fLex_Q5g;D&2`OK5$|z09A@#@$zh3C?|%&BM(I>pc=Jd`Ou~;5Ld1q!IIaTR+aJR$Eu$43{*Ja{fp&-1R z?u#S0t1A<9Qa~ovJhC9okdO9tS+)cO_+)G%)N0;7#LRq3vQdui}bg?9>!YQe6exxKX+ zlqCK7u>95-_F%#>s>jUbljOITMa^9L?Ds;jI*;g zL8}z4*Br(;Nr1G!nV#rJ*E*F%7q{b-NEW%*Cx=v5X29tX&Fw+czpCl z*CLl{`VQ-L{(oW;-{3QK7e%}Am@?6?O}Wp+m6vc#KE`9#)F11;gE-w?VYVK={5O#H z@5n3k_p6%Or@vRe@ikvGdCucM5G-9(C&ycYJz-bBinKJ&a7@jIMeju2ka5fb)>QfP zGFPYm$Gt$@5?b5Yh~X-N_K^um?vnFL)hIF#tLPZ0qsPt`rqzFqc=jikK%-JBdpN4Vm=e)0%8?I=x-01aaIm>^pQiP`6Q^5%;_IpK6F6 zSIKE_9Wy$Ee`NE5v~%Sf_h+V+kAF0xU|Q!FUSD>`AY9~lvomuRf{Pzz~4zA_*Wa3ve6DuCgUYQ@& zrm6Qb4|kNGENN1zFJCpsbN?ofZu~ihZ7DnN(6SyBCw5@Hn3th(`%L~kUWaSiK#V>V z^XJt53Xgk6_DB7sy-Xo_jifN!;gPVHuQSy)3FJh5GH!>-=Xqu6ekv5~Q40(>@P9lx zcfM18!TEP2_$wz0S*{DnbFh>Q+$iiHA~6#kAd&EchRa=zss2&}v_Q z*a(b9+u8NY7hAwes~CBVf0Vl{a_X{TJQzj&r_|PzhA(o65@6z0j<2l56GHUX&r~Gj-WeO0z#@?D9L+XIQUU0*T4WT^Ai5j%7M? z+{|$kA*KL1+G?0?Db;>4ZVG~K##<$02cJ1xLz6yGxY9$GO}S=SoiP`I7uh zEok0Yk@6f3-b*u0y>_35_3^N_)gR)uL{vdM$gsa%b|bM9P30CN7w%1KWE!IW>AH9w z)1~Jm>~*$26822tIwPo|%S(r=Gh38i0fe;k6$Gk$q8I^Hltt4d4x*ETRi_L)ShOG} z0kWazYGl-hqpS9vi`C5F#*e+H);md{Q6MiLp_#rS_1+WHu<;wi`_FwRt;ufRE9u{kGu;2vrOIUgX$OF!1Mgw9SlJL~jsf(c zll1FrXDv(4C`KRAH$B04pMFfxHSlP$JB~~z2U7^qp`mE~S-+e5IhG`TV!(`#Vgm$F zKto7^e&BO*v8fKQufN=~AfAqQHlErjNkmJ0o$9x{DU+9943X}9%BY-aBuo+ij*@{# z)lO`?YO63s+YXO~sI2{PGZJ$DLFcS@|KQVW7#P+{_?pVP^zGLzN> zDKSVh=W2nAYFhM5YyK81PiY?XMMtL9nLjQFWGU@Z%cYt`8P~PRyq@glA5F=nP*nS! zOD{*bv_1Y$$n1^98#JY z0-aX;T1{H5JkJ=qm|HyV>sS@Fl1QY%Bl`!AkG_}3)yb_1wD;qW0U2f6)B06{a$1vY zr?Y{|KI@lP8SeM!{thUz!rjd=){78Xb&ob}nMDuXS{M-R*dti#x~O1RN?wv0E^gqk z7R7he^0=6_8Zy1q<>DNq0DhN7^n_Ppl=(VE?9$TjyZ2#RnETzG80y5@pfAGk%%m30 zlG=6-=7YVWDB^WjANn6q`9JRmthg?Q9~QM${XU|X=k$s}5SS$P2KOj=G$SBIikOYe zFCW*Tg?y{;8T-QXeQGG1ATYl)Wq*GHogw6-Nd~-jq-+x_=oyKIMDWJ~3hmEEsXg(` zdRsFhHi2iPODdcuuT`00ppBmddZoB4!Ydf^vN|I6?af zOT}{=iTpZ^v>~=Gwq#Hn@GB0RT|Gb*0#s- zB~xeN)#0UEiwRcWiL7HRj`aJv=|5}HLVxawvU1CIqxZyKp&6yWl_#8Yu=Bl|O68(# zdllgF4J`tn)cY164;WZx@{KIXMpg@|Au{ZA>mVJ{O-k*!82&7Zc&Pv-#b<4Q z4DlPP^1F39okVv#%$_(zugsJ%ZukKD??j%a{0iJEI)dKO)NVW(tu(eoLQCBVZU$N$ z6(}XmuH24D>x=K$Fn`}?<@9pLJJAlgsL>B;!-c!BMjhA==*<7C3(R#2{HAaKR?3uO zXM0_lwDF7qjXY>F@Dtcjjc8J0p4Tt_)-;p-$8;1JKFs2DjdwpQ=?ng=c0W_A{(V2{*1dO7O4lSi>wROx-#gjH{>})?Q z&PlU`+>nxt7GSMW1IOCM-rC)!{R2ARf2V7gZH4*Or^U>t(40cZ%N`XC5?hV6V8&SG zIx9H)*)l|q-iNFbimL(^0<40^(fxGUHZN}QQIZM8=C`+;WhLSH z#U1Hit9M@EqItMRl`+c}Zv>7!P>r15pnp>TCH8X`UJ*tG-JgONDhXK&%q&WU zUeDLrepaR5Um;+6!p0DkUGaKgA`)mi=;}VgukgY|UqCs!xvv3WrLVX4+j`r5+6N7< znbCuc3w1nK8Gi*I_4ntSn{pXDTL(F5o20#)?DY}(YRV+ZSiZy&o2&C7J+g=l+aJpB zE&Hc@E~%^xQxj12Tk)H5F!d33`?P*s=A(3h!M1|m<-e|H1G1jjP;TxGy9Z62NY!MX zAWON=z_g|M{}nJqV=KbY($cft%rq$I{=S@D+#K(~&b+_N@1|Fe(`olyT{#KVzKdLIa*{*K1mC&Y^#~X(p~4SINC>mL=uSM1 zag{ZaGF&e@KIRmLuj*;WPt+;ONav|8f0R`o+ikR{u4?bOcxB<;lhd1FJTQ)})_Di=+ZxWxQqtzr~AdTtS8 z3RV28_stg}%@6R34VD<;j@zZvrsjw9iUMA?7s_@l2SC3X|Bp2JKbS)GC>-_|&PyPM9BPB%}abY?5waxR@%eORMvm`%rYu#6q|Rb4*Df&fn)7EL9ODx zq;u`T4P`utZVRDo%vbG@VM;Ng7{P14?;A+TnW@ce?tLis~QLC22%^CPVeKxg#BkaCK zN;m{o!xQi53yW|3+34zsKZq~mx8D5=xb@GdUF$?`kJxkc7lUL~4xz(3h2YFi?N z-o&X47t0lvUsCyouJ7cjD$5e4cl&5hTLmL2qg<#utgfhOef^;7*SyxZ&MxkE)67Ly zWy*^h!NYMM-E3uRd3sh$>EzUEk+q7$PJSQt6LYm8Nn}iAOrdW}T_*<_W{p1PgX(O@ zb>cS!xR~04!~+P~3;o$`0x=Y<9aO)0-TbImCL0krxH>BU>;_>TW~BHOL{tOVOJ`x_RY^X9*uV3gZloD&G_Ci2{-mWp#6=9xa4ux|^YSHnQF zV@Q1Nz%UR-G@DfSwcjbKGWz~H{n#v6Nj0@m(4}0_lsrb}u4>+(cl2RT=xRAktgFPp z6B`QqTpA{L4giW&IgI}cEe1HJG`6F?P|w4Z;13rMP^Y98^@W#zewLv0#9Ov#XRnq& zLA}r@Ldxq!O_}vv?3E5qXsx1TgWeODoqWx@FC=V>J_c{Z^KHe!2}*aPvWA#y?~^B8 z7s2Lh{lW1CN-D$@I!_>8JO>m4E-WN`I-m6|X_GuGP1D1OK@cu5*G1xTz)RZoY5(0t zerxh58IaBg!z4ZbefWRbb9$FKWNPa#sHlj-S@)xr|Lh)|GXbRoMCaQsLoTL4z{476d-{88v5lI`71|;KBss8H%lH5q9ofpmALv!3C=t8 z5}A?VujJLMz{@f#OE~0)At+ ztS_BUY}k0JL~7pMGcs3*ApZk17UnFR1^s$rX5*)PmbNbo7RUR0%jG#$dQ&H88L(oCmGOS^QMZQ4OLE*jip z5O)zgfu6Q+#C^fMVe;?A8z~l>B(emzXpT%`UDKxF&|*C=RVs`MrF*@KCx&?@Y^tRa zvF{LIKrT76z^|vPn!6i5f8$9QW=Be9qv`WOKTDa!K(3z2XLR%VrO%H>=%3Xgin_YG zK2=3TZEkn`s6sj8dgz!Ay62AVZr2mA)O@JfhJ(S{F`9Dle4{i(Jjw65^&Sy*_)02_ zf+%yXMy?tSv|hB?75CQXU|dGP`+&OlecNi$>tDcY_{kU_>i@mgpd$qa8ZRQ0o(@)b zJiYWgR`NT@Y7WY}()EvUzwZIoa+sJ}7rZ4>Ew;m}EMigEjsI|;iX6qPbB)5T(_eCg z0yR_A_ugP;3gxtt?n2Y>VKjy7-NYui@=SI)P@qtBd1$7uMmU+!fk9G)EbJKE9ukb$ zc8NdqTTAn}w{DH#9Wtuxi3MSzE-ySr{crRST5cnNgm?r}`PMO*Ao8W8n_INgYBkHB zyCIGA#yzfRTCouqQwS&1U&{Z~_-es5#6b%sMf?D$hZx4Kg^?qSbP>Z3JyGaI#LRLO z_BL@OL6X@YZ86^LeEr&Sx9KEmDv)Kms%Ol9*rQe4O+S=LxT)bg3;{ZEf|{*q%1In? zH9*eb`?7=wox#Z4J4`J(%edOn*mCm}yEU`N{*Uaobr^8>_c>6@0?DiWJ8GQ%K&dQ? zsJ(5CxV^gA)qBdNj?z;gmI_b}7w24N;9KmgdMk6)7bf~q8*m9X%EUY-{U7N915)$G z%|2=H$d-*4txG;`v>joKJvuj|+M1IA{i)yDoj@Hg-*vqGy||K|UuZAQL$xOTw0e=1 zNFwB|M(NidAL1UC22~DUp&q}i$g~b}$vH;?C2=y}jl?Y9b)`{-p-p_5CedMjhrq3K zix#$ar2tS-4f#c0n?354x!v-&iau=eyKPSsK?|OvB0eWXS$#hxGM~Hr;je3zu@KL^*nd?BlG0^1*L?oYwry<_k|7X$ZJfQ zb;oKh-1K^!9oP6QKR-ml?R`GXua&SL1f6d=V*dW$^9L5-99?Wzl$Pqmi^^;|T($Ju zEbv@Yo-^tGVo{Bt1nqRNLU|@u1*D5Wsv4Li2&18$f8e|&v z3#&+Wf>^U`Q{FT~M)RHyg!JTkn=Z*OpTk2%rAsZ~mp*P4Tx5NPp7CRpCmo(J$RL*l ztg;3hckTGl0Fly@jv--cPzJ!Yq_2MNiELJ`(O#?-q6GSf4Sq3(6$r zdrMxoW1UI623H)>fBNGV>z<65)A2t(~#tPuMz}(LnW%;8KSe*dN zhk7ixzx3=^d~b2v_c`}lw@z8t!6fB(-E;18FcWVY#+{11cpyO%GZN6YOJ@9K0+u|SZbPqe80#ZxasbQ<~lAo1zDN!GOL9Qv|j{GTPae~plAXF10%2(fB zg!Kq~1~WjDTw8vRP=>e10&7&A_qybI)?NW?5pr(tf(`dAJ(V)a^!$e5K9}xG(gy1( zNTYTlE9-_ewYJe-u{&|nhzub^^|;iMPi7cLn!x@k#6t@BdYXc z|4OzWNs)|1;VXqDPCvpeKP}jB^tgQ41Gr#c$eXN@Idf%!b9UR)fCTZ!p|$Bt#% zUA#eOzR~49+G}~ z)AI$L?-jkSLm7OXE=mil-Ge(HZ|dX!k3H~^=nC1$7IQO~(SJPsR4+1~RdC|F8*^Wq znRa>)>me7t{}FQ>?~f|DT7D_E-XHs%VwICE+9vk&KR4&_`$sn=JvV{h+g+L_T8KCm zYc{9>2etB;HYuS%M!h_iILWg}Ac&IznKA;IMe@`HQ7G!WVnGo%Mj(_PpLb#IC#V$6 z!p5E!5ULa5$UM(IozwqJJlgT|Ve`!sQxVS6-Bci9H(czdw=JHiH%6_VP4uca{(4^Q zLeB48^WpW6FNW?SrQa9gv+U^@O2Lt6u9ViYwK=jM2#aLl7O^PM01+DajmF#~l`I?> zyw?Ex6IKr*D*9LHe8v4Kfa5S|bG{jV*=O{A-==BB^Ey+pq1wK}wXkQJTrKuKy)x@M zir40qYKZC87~ri>Z#}^}5$@GiE@sCe^lHs65yeUa^SYGhLnUBW!P*QAo=Ml%kMu;m zV1}gFPdHkZ_vsZaf2jCv=YbH~;9W`P5cU(x3N1JQ{-d?LsQ(`xRhVwBhtZkWHptoU z=`1(f;6~u~W=b6oNauNAOOOb7!#;0DegP%0Og z+jcH5Xjb&qj(NzDr^wbP)AYm7!tQ>_mv;qAtFOgQ@ecm1;RQSM=gIzccX>vIz_fqJ zu>Jr6n-FBDkn+mV?biv)<-?0*4S2W^C5lD$dto z(8Z~K<}1sZSI1hyp|^^}totOcpDep_3qs{H$PtE*e;-sf>~T36Dp)j7;C~8TDUnUh zmojPqvZ1f*((IPAU()1qqQ7O({#>cYdKL4yy?EC(+Z#74S4+&T5n_v5({f5Jkumi5e(3HA-XzJL}ifuby#f)?l&y`{vw_L0a;1Eg-;bv>RAu9tFDb3EMRyMTA zk#2&bpjCKhA5!$ZKO5odKn;W9H?`1k0W;cXBqvT5w#3I&vL%O_m3{(*{aX`+#RIKI)x{vQG=E$FPWHD5l~o)|3&(hzvmal4X_B?&YNT~ zyyprxR??oX?NQ}vea`tF9V3qeX%eL@ktiXKb2*L~ah<+0#u&*yI54j{6>hWx+MnQV z2|1=>ZDat%mk7ZN%MaB#Mwfd6eyGL6Rocfrv6X}Oe&Z#d+aJE_1jPmd(BjearAyzt zW&B49C4I*iI?$|N#XPz)(e!W&fB&pv=Fbvi3G!~V{zHs;Sg*dKy@s%aj|X?RKQ(Xo ztLaa`8gDQhp4)|$mCl^k1!t4Mp5Qj+pi#q-Hj@%h67xq1XAz6T)gg4j>qh=r!~3>C zv_6l|_P^V!Jyh#As4l6qp;~nc+co~a-6;i92P3xdUs)Mk3i-WOEiEj zCGP%4l&l}E7T!B58f{Ibvyv!4v6qIVB)tXhWL5)QlPw{#GIWT?rR+LycT|!y^4wBI$}&InVL_h z=r#4hyNX28l#OlKVewW88igD^;^K3O7(h8{X#s{Ung2xxgy~FP{xi|eflDxA_K4S% z3Kywjs(KEZz`o8Qjc^NPnS&NpFdiRS-xF}PYss6kD)n(J^<>j@6Nv0gFAxvI6drXi{7DLYS#T+)|G$}5vb9w+^!AHI&OZ_5z7MLj$NI2^(}-)|$8 zAHn?q^BBe)9ds{p;XZ1*n_9=*@-;2rcm%%|seVdft50vT;#;cm>Wxihf)1j{f@#=+ z|I;p7M!wAfbv8M1!1u=$y}vr9EtJ$YJ-_=C#2n|Xua{*+dn^y{=(&bA?;rOv+?!tm z=UU1S{iOAGWE^$v)qJJ;PvD!yih3 zfkyfalbkm{s4A*t!Pa<|tGd*pWXWk@sM-9{V^joYEBEOH{P+O&>BXs%rew>>)s&5DH)6YD@=^5o<9CU9xJqZV9 z3V5GrK(YgTXg5rBiHUnu1U`~pl>-CklO5KmA7a^=^|;6mgMeUHp`wNZF1|r z@Mq@2Q0i>gNfJBGo-rGqt=)P5C#fikL>*i_Z(w)P4M6Z-*nXQLdR{I4$1fv*AUEQ1ry1Lh}ZZD`p)FZ#bE0IRk z)XJ3yDv%rrHS&&GJHx_>>`DIU&PG_R#N+ZCRkZnNuNLGvSXf7>FWsFxO_4bf3$B9; zCP7$^7>}=Z=gLL0g{zFrfqC?A`*e84sxsHUP{-6nGbsUs2!zTo{f%&~=fS>asiw6$ ziv}}v0FhP~i%Oy&d{wNrIluirT^;V4k!ffuA?HTiyW)J7>E@h6^d~%eS&4uubr1V| zWW`1tt|JAOgX@^yL{gkxoGq6<2T8~&eBOI&;j)gNsgD;sUWX_hI%pdfZ6r=nUz?b56jmFar= zESlQPo`FnF*J`UHrE7k0l7c1wLQAu!Mm{qqyb-kiDasu+`}XZnGs;eSbHw!cghYXg z(xkE?>}%?B3y>w3FtNpyQ|^WT#~z+(P~B0v-GAELt7>N>f0AJu0V3grJJ&#>wwViz4zu|x$gXXy`uUP#LM32{JSZYi>%@8x- z0=8DX>6#ma#uy5uNYd|C)j3b!&Yc=2L)0o35;{Z$4j7~MP^g9*M9hLZO6Kf1L40A! ziP@e0`Lusg=Hy**J^CRM3V|n`1!=^uN8d&ye~cO$;lR!-sex3f;mYa^G?f^_Z?sCz zMs>2s->g2rC{LPWkCELHT)my}(DPq*X74z=q;(4V!hAvEfg5OK6;;g}*QFn^PUdPF@tZOtn<_Y2S?Ab+z^8M%b5)m{MA_pgx&F1Fg8!V~5CwV%}>6-X`BQOCioEPvt(Q%Etb%CE; z0jWNU>}^4MG&J(4)XI+R7=KfeKLfWw?P{KJimsd|<{*?7QR{<*TvSU^Sq#m}xFeml zQk6Cmm3$&%k(S5J$~5afwGO9u3O7dPN9YedR|J-((=6 z^K_fTFJaQ}3Egg~GmBPP9lTjtpk2W|ZB^@h>kNC$zIN;hB>-`8Nln{mRB3&I)_v0E zt=7(I$iaI3SSNBq!xeY+lo3Ufcta`0u+b_`YQLRwFO4!?xBlX?5<`tnLAS*UH1?Gp z7*Rg2E})o6pT=6SIPtr7UE!=9fr^MMi;@^DHMtcnfqS%~(^Ml7i?zZn%^au=q6MiH zK`OXGpfHy>#whEU_-Tix(u<3=&|E>WxTaKShYGYJoU(LSO$v(vZ-e%)1t&uVq7aGq zV5jJPBTCP1f>E}pbu(?zAsV+V6vX34te2gn$t-Z}6e_tcwB4f7<~NPH#!vz(OxAF4 zH%fcSfkX{XvugbP{mA<6{yw7k$3kP_7GVj7gd!LWHta=_C}EP4dL!AkVsf6OdNwfW zmwNnoBGj)pdF~=-qjm z!f_f<-I4mq|J)mPH{a}XOHxzZ)f^7%G#nfv;UO{II>OKSaRn8-#x%-ZocJO&<Tzu_}#b|Q4GJ&$&1(APNfvN2J>IKzMj&=o^EqUb7?5a4z z6e_EuKr^Rg`L@OXg-0S(cZl?!%vB5H?5MtgA>Y;dsKMz|1U5_zMj7+EV`3Rpd zMg*b78Z6UId1{8w1fmGr6{~S$VR_ zY_an4MF9n;7$^|b({qYa&2@D3B+1BuInOPWxsavgxUB93^dll1+nr1vMW89aw%(A1 z-1~tR`3pFNB|RWz^$#t0|9(p(UDsrTavnGXAg7|BYmIy3HWk#9PF>rQcI02UdEv{# zLt&Tk+&_E>YDDf+3R50+Aiz!?=9nI{>q3C#EU!xo#2c>RP~1~20|A=wj=#SCd*%F2 zcPtYo6U%}qB2I-0CbDgdw6;xeZH0Y8L!~fvQBXuD@U7^Gc8^Wx+gsZo7gk4jfi$eSLSo zS20(r#mqxbEC6pyWuW5_@tPkb90THJ#!}gfAXSOxMDv1~4Jbt|&w1g%=)Ly^kzY0< z*cI`!a&5Ruc7&e=kH1J^on@2n`SDX~LEL=&`dY<_K9jc|pF5`gB2P33U8Bs#WnfZ_ z7msw$c9~`4ud}`XPT6k8Dy3xq!zWDj z2o!4{i&xqUTGkD^BX2rko5n~gNDA9Ra8m_l3Z;YFciiB0W{X^6chf+|g6h+!(kA307UW zpAW54+9Ov&GggN7pa}5^YLEuLPZ+%6>^a-IyG#=)`Sg)^P|2;jsc`Fe@z2kx|9*>z zX&84u=CRlrW&SR9gvSS5Otv0B-QOIo-uuC>GLGMu;58-!iC&4cy=g)6ip&b6-moZ> ze9&VT2{_WbD z3?qp{6W86n4}!pHKMwGle;CU2IW-6NYE4vuw4m_g$3F;q!UZ4@Osj#-YkeAwOrcCA za1_&^+is;WjExr9jE@r7yXw0yMBaJq@JCO03m5aWU1)h*?H$>q1{D%`FAlj>>HwvP z#q^(AO7uE7*70I52n^qlNEVw5(pAwpKh7+BL`*hKFp)pzWq}v7DF%g@ZVq9Ec%Q4@y0DJdP z!Ni?Q2P}>k(Bj-VE9&UXLMY7`TK4iC55?1QKyMsd#!biS6PuyWIud~VN#%M{srgaL zgos9C3KIdhWo62ALDHkc(B`7i`iC1o6ojlx`Mg?s49JIZ)I@nIEKdS$d(Up89W zS)SAsH{Ah+CEA;|Mvu%#+9XWo44&kh8|V{o%;%GM-S!88@|5Jk8^%|C+&`9Ln@p_k z*3cbg6yJuip#ii1IneMqp#5}T_4~6tR(h(l+9Z&SG)>uT7sN)ZJYXXVHJ*507HVQV zYC@*n(8_a9CP$O{XWhI;>Pcl3F0NpiFN5kj>e}GQR~YPO-9r175R^)gJQ-R2MzuEf zV~pUvrK-iSrSH87(;d0OA&KsgLW_9eymJo{!IT5<%^z{UH!0eJN53={8(jDwrDw00 z;qJkz3#a3vjg$t8p_k;L-D{CX zA2XUT|EjMfs(nFg?iHXglBcGE{PjO)xHdEoBnD2_w&qKZQB^w0I(Yt;^LS_s^Bd>Y z_qP+k&7}~2*XqD4!$Zr!SDp0y_zZZhpezJ|*CI#S z(UGU9cduW2!rQ9X$90TioAD1=xr!lmXFAe=VT*RwYjTu_ zOh*?kH*eE$ww0vk-m9?ev-)TUs}E)6|K;t|Mr3>}Dw|*$^^$7K*gPT&y;sdONN?fv zRFt%b;h0P>6(l4y(ch0auUjvIPNY`!yVVr=8s@?AYPPuU@FpoDX_tsv3pmeRXsQNq8bX~<6!FdS`V+dUFn5)>Ppam>*YFGP6jDc>H zDg8nVcsgEuNm)*lw~vy8$<|F#YEe5fugGLkj`t3ZiiWu|`Dv}Co}*G8&X!<6L+!KQ z{3p*u4OPL=)#tTv-S20JXCgGpHfDO!o!Qy&fLd@izYs*=z_FDs&eUS^L-)ai58J_f zRi8k3BKC_d*&fmB<-QdU*q|VRzEs2F+TM5uVEL41`lFYjOp~8Pqps1wzD-ebQt(xKI9By2Hx6v5oBo+a?QE@O7S+H%`3YA7vNHzbNEsR-) z`+?uy%*2FLy&^FJrOdq9*MsX^KySu}5rydl7MeTnb3$H4b77pa68<<1O(;fH#|4Rr zNv0Asa*h3vo1aP}w0t@gq*a&6=8Y`BH2tYtQn(db^j{45k`_vH8WR^c&5q{pea|&EG{~R>brX#$Hgx{%ep=*#PUL*)Rh%pNET_Cr_Lg$UEc*H9+ zRUu@gM(NT zoFXFq@9gPsv3qe}0|I6uWyr^mwK>}i)f<)Eh7-+Ct8Z@Nz;&0|r>9QU&pZ4h(Lqmv z{)Xq}Iw1RxU!YYgt7{0{mg7{3pt)@FnMQCn?>9n{A-%Ee>8!)$*5Ldkyp?)$^mx(l zsp3yl_j;T@Zy9QYLT8Pf_|Wk==)sT}rrPV=}Qi6S(5?l z=b1j!=B07*4>d480o^n%RG17=0UdT}_il|ILc0 zj=sdOW;%@!j&5{^OzwSS`LNRllQjYcTHhf01qZJ`urM**>S(KY# za@}*zuZGTo3^`BEN)Dx$nh27(ay$&gvF*L??2jaUXLuW5Slg4Nf%?1Ep5(f!GpX%wd(u6{ z9g!(cv*WSowew6_iPH|t#79RfA?O<{iad9YA>uihSY=&I^U}|3{`lthN3!LU@tX5i zRf93!u2c5AJLHIsH21bpCN!*9!^f0!#W3Kc5axH;E>t z!m|pkM}ym;kP0tdh=sfYgY#*7%!nY?^&$*$)Rij-N!OVle+lo4iqcvWgSi`G+#3`+ zVA6EzRG*zB*&3i#&QGBP(>9h5*O&om=Nv7ci^fu^Ua)OTa@W#vkVBc2QgLL74@9fn zN$>_(b$`UHukYFYu1!c`iQ5DM{MHi{IV=I*uvA9_h}vj^;(ZpFmuCtJRh9doH!{_~ zhw@zv>rR=Wipyd=eV`GYW9Qeb3cReu{bXzN;AXzL8m_VM2yl5%*DViGES{HMa8M;p zA=d85xe-c~dxlxmBa_j-u884lxRSdm+Hidj z;dva|!MgMs!?^pQXIiG@MOjSK)r-hv#h{SRfdn#`y)4Hh8#LC%AD(Lsd@ZII7|T?jW}QkR5W)0UbVWM;pV zSom0BHe`rgZ>;2b=egEt)&h1jxNsiEZ#X`>scPnFMGUb9;@1_jm*f~y5H6LLD46hS zpII#mD>P>Wm2&v9=%NYgJa5s+KRgSFKlEJRY&GRVKy$Myh%6qA6YQ>vz!$Vbe;kepy z?Y!c)Q1@{f8+JP1T<5qR#7UHo=R~@hd6XFsfSzaQC_>{u;*BuxprFLeW34#37j5M4 z%97ssNwC=<=+k=sM-4Sx&mQiVQ-0Qb8Ncpcdp(lW?6hpNMC3<+p?hzCR5qa$oyf;D zRQhdM0#o5G0rY43nL)*5LKLpmej58J|6gbYkIu1bgnhc6u84$|b^uBVt9DTM#2`e)DCneBPGT@JF)j*jJF{U;X_i;^tL%l7L$R zigg{>l`X5DlSqSQEa!J0OfhXuCPk(a>?&TE4^Tpg@Nel2It}IY=lE{X_?}>jb>}=S zh;MoLUtbIEZ6(z)Mp4W0Wb86Zm2raBgbxJMIRBcxZh%zHp!&2KW+U%kYk@<3(y;nZ zVW@Ee%0z@{y|UsyYruRdqX(uVR(QHcSBA!<01lb;8LPC1w{8_^w~=)Z;5~8wxBb)@ z{kSiM^yDS8o4nR0mi~=O_v%a0;dFsLr~&$*=IkpLe(egpd;yD_Oc%jTt(rk^)n7zv z_ULLT+%h53!sKE3St}kjXs}wQ^Jp2X@LvIk zw$q`9y&V5ERo@5GcDQJlY{0RtLOEW!`R!3M&R=mNnBe{;G0x^@Bb3cz^4nMj?1COh z|E@VJ0`!vUPx^fdCD~z`AR(2AM*sI~yO~9dKe=BHSgwh}d@5b?dZj`VkBrRVCRLIL zD956MxQs=o62i@Pe@+mMZVp!)Huvn?uRQ|3nh%kMd&E&sI>FwJl#*fYUFT zH3N0TUpG+e*UF!5mR%4U5SAO_!<}9vqB7qFrM#@_#b%PMq^(QshvbGx3&_!-cKUc_ z&pI@{ZTVC-^OKO=!qY0kprD}fECyU8r71QSha!W!Ubx}2`a~dhRTp1xGJy7U_s3SR z#SAsk@d*Rt0*B=VETIXS=DVLPBT7Z7kVwcxS3Uerw_M>T%Y;}){L`%wClBXv&hui< z=?b8EkgFEBt;P6^tONG=qsneVY1|>)K`c5D+`#e0C%>_b#STl%oQHm+v)K%PDQ!e_ z#$(ZW!urZs5Itf9vU<7}G`zBG-dMf-{yZ?v4hc&tM5zKD{_|#+(F1m;A@(%=+(TAz zyy4gNET$rUu2hWq#+^keQN_B|1)pqS(wYTOX9NYd3x53Pjbbv>Z!p?n-cn_eG(-`Q z$rweHEh_wTgFsepZM&PdVnQ$^+`S<*6`Kx`o?|#&*`z9>ks6Xn8}$Y9nU{y;O{SZ` zaov2K3~A#FYjJ6*)4=jfwg zfxJdpaev)=+ep{fmM$?MR^caF*mDo2^SqwrS(&QAkWS~x?F_{QQm>$@Iw72x8OeoAwFhlq)Fg+1E5VG_tU=PR(?_*pPRe%tkcdX|8&6!>ysdnZ z6w%=etL8r_th!4hp3KxmBMmR%q~95bmxz8OA-T<)RMO0#71BoWD5R^E6>H8QQi;5b z?+?#Ssx6K4u7(gVG6l}6hdd+U*$-}IUY&7w_xW9~j9r!Fn7Fosnvff}J}YHgP8wFa zEMFy2oWTQtmK^|3@*ewRqNlQ1nq86J-QOu}5K!=ixrablsdxN)A$xa0a^$__F!6X077+2Cws>wQKY5hfjHPHi_EhGEPBm_@+^>{Q0DY z|2{gb)^zP=I+InTSQPZ6GAy{<$BOTyl6*270Lt+@ASxSf;7mlr4Gb?V(N;K}NPrW` zs^=!}m+t~^2U6ng6pep8G)978xNBUULEGNZo^gAY%VeLey28&XHHz8dH*3mqEL_es z5eK5k`Z}trSZ3e2J?6Rna|&mzGJoHl0ZC=H22CC91_wLcmnOsiIb)<#;557&5Vr7-K=y;paz)=p5h#<3M}5n)R{F zDyfb7>B+2+aykuqUGnBjGgl0ontI3x7e1?Aznu6LNbF(#c>;)mdj1*kIQu*Rz(Z+4 zX`_z!7H>jbezD9^rfND5|MH=)85udy+svc^+sZI$GHY2(lCHm^xItKb_@i^Pzfc38 zZ__?k{L~VKqn#zy1hxEVm8R=es~kd!mHO_zaV%&n{ zm`njT0abyU#VYP-4L0X-+MM$Q| z%LYLGf;|7bJ$rrPH50+Dd!V zt?jh~^r$}kctD0ysAw@xMz-;T{ruzMyUvTyNkEiWf&p?k$aaGC%>Cp`Y_gO>C^(T) zY@2jm_s-jA1pO5ZXK0da8F^sq)nCMW;ouHrQ#L3|rpv|El?j@(@MPIs`5~+$8cav0 zVzR@bH`)ffWEVTt2^b&{zqaG+3g82Z!0 zBopbaY!wo7Kb9x=zw$C}xnvNx@XePj(x!>yaTdp+?kat73rJ#|7yRR;f;|9iqw_<# z7OfD_gf9};`Q)D-`&uD+YU#szj7~@Tf{3H|g5Qn{t3gYIx#HKU371TlEj@I$a>ryN z4molkA4ZoK5VSDMiNa5wA$i}pzX|%VU$1&_{F}_KYWG`WwNVm(B4;cL0P=fhDHj)) zp-m{tg^2hs=4nEtm_yHjtU@y=l}q;ff`J`|d6(mr3a`UcH<1oEbk$0q%(?4j>54h( zIO;^k9l+wF*X;f#`YXHiC>l27S!Rp&(x>ko0Fa(yIxhZ4j}Kw3^mxkYGjce8w_h3@ zGkoIO`I!;##P^W#n?=`^hdRiO_HAvJ7<&e6)%00KEqgCGP=l3pe%6!NU1z*MlO^JMQFNp|!!Ym)(4ieRp})D@U#t4zfdLBzSi3wA2RIcU~`(IX206KN`re+27fy3t2} zWh#zTIz}d;a z34i6aov$?+0BjKxhuQ2+v`Xw&Ri_ggKxgG9)xKN*%?;ytq@YdtN!tigF%gjerKn__d46jM-e-a%S~LRCt~q>Xas z-ecdqA|=exa?%@}#vQ;en~>DcG@%Dr(b`t1<4n{4#XbU*BQMaZsqvxt%rz0wn8h}y zEw69)#Q<_$1p}YG#bzp7`*!4|QU(Zz2`NRu#KaEsRq!m~CmyRtsOEv2#m~$EpXa`S zHQ;bjbv{;oIztY)7^1ZX`_$&@Z%^U0(|bxKq-BRXQ0Lsb*%#YGy_ zYt+nqI-701NK_O!Uq1ic;Ue7i-1eL;?9hcng(wsmnQXBTm-PVXVxB8V1hWg`pV{gs zp31piK_OhS|D^;$LCBfcTe5*HN@}fc#t-bt`6*4iRhPLbXq%-#AZR9O_wpmkps;Eo z-aifxqE@pox^_M==+oXHfctzF8?dw96n_#{QEg&&r5{yE8MUc`Ke`!(!Gzc3jp^ku z9NVX;kP0X4HX};xJFH(;{k;F8kaE)5-ELLVf|WTcqNx|3=+Zk&WKsy=! zM%i+@-dv>BoIC#c0Z!U%21=N*dW=SD1iyV_`v%66JnxAqt4n z8q_WAoV_Jtdn~oVazW*cweOGG__Up+d{tzAn#knvdHeYtZm1lVU6J?Q9pN|bufYAj zdqnYZE|Q^cCy!T237|CSt_86@ZO$#e+rfqbQb|5B*}Wl>_q89EZ7HCq28fy?K!JN- z(}{C+^p#UCWVWwKN5DChQ3OU@`<#S7`Pz=^Bx0R{&GPY3# zql`9l0MhRHTPk1-WhIj%yP0!UliUg1#cn13Vfx zSt$nw#%?i^m#_e8M!WB+iv^PLpB77eA7+ao2l8_QI61_h+mZ-PmXd^ff6 z0Uz&uHx*qs=Y`GRK3}kvN=O6h^*^9|k)lM&?gIlRmfcE@u(NcMLmh`n~ydiq>!>DP|j}2L4)VvPi(Fu+2ZY1r(x9+%6{{i2c$O zZE%SGM4||?_jW26Ogjt*)n38EqgF@!X9&1Y&hrd7RUkkNi^Ekvc8XpU0W#I8`e?E8 zhu=TE&>2{b1`k_Z)Ug}2Cu^r8g|ta0e4^qOc7EzL+<0_73iA+eUR+&nYQ=yYYT^qt z8LJ3aJ2FTdZtzw8w#N?bn!1I(_jzF_#r&r~qB;5q726j3qt)h_5G>IPIi}QQR=X*= zEhePU0?*%;(L%uGO?TX|xQ4eI5jd)%v0i{|;I`nGZuH~EIh9@i!GwJ7D~1%xg;=l3 z9Rjr~vQ29;fFK;M-+l5U+0!708`!ni(E#Mx;IgSt2<$8?gxG-#97zK*S|%ej@gV5&jV}T zC7{wfqom__Jx@4a^I@ope|5N?F1q!O?Gsg$Nqh6XRzsEyYT#uYZJeIlAPYh~E?4_t zcx8zPxtZGgl{$L{{*?#Q!Wk4Q$mB6fv%=Hvr}x?$sNn$4{I9n06Vhz)WD&- z_nF03MS`b=Nv&J?(Ywb7G!Sf#-ixf-)DI4iOaOw9W@Q-`{w@OGfXSTyBCD|4`Hd{O zy%wC$HeummR=gx;dSSTh-#=CM_;~!fQWSySibMURIn0E z$w&kW&g5;$r%X%~hzpJ#d;yF9l2{0lwH@fC8*8~q9BYMl-g|D0ycsslGs)c|qD>eS z8e0yH_5$vXnFS5GJ*yhN&sfXXQ^bEeH{H*u&1B8Jf|;1UVUMzu{inL`*&I0+(bXGP z8~nYr(6=EQO}NsLQNnM3_@`P44U4R*JZ>;VtXE_*GCv|P(0_(@0C#8Ad%=*)lVU@x zhz^Fls%(lLMJ;ZX3c9c&wo_k=l|<;ACDnp7GISXxl^bq-zTh zZp}5bQgtU^H_+{Rvz>xGW>O}fM334b>INu&weBlI-|d#dK-*q!mD3JzGcU;^sQKUa zTR_j`M``qmr&fwG=jYSX2Y*!p1rf=R$Qu1>gy33~v2&Y8CNVrxZW-Im~{1 z%*!u85n7ah2Q~G_d~5jKX-{%6FD6y7B89RzLMSy7Pv`*Hjw zA*KrAH01$9RhR@yWF0;OZ7A|)-vQbIh#Z63jz%FOu~2vq8|;iZ^$M*=2ZF|I-TUzw zK{_~CCgE@Sp;!)}*$zvAC5s@Ea_QgBcU&d}Yu>^gNrSO;5vYJxOJT2z9^~N<<0|NV z({&>E-&{%qkS9B?0H_}Y2`McsG#lkC2KXV;@E19}J<-l**GJkoKpGWP5-gcbV8s-f zgp1Mvoe+!?VNl-SY+*%1vz=C7ZUTQ+xsvq^!R&~ehc?dRW#uVq)D*GhW#ErO*j2hs&P4oAYd*_YvrB@{ zQ59C-T{6cNHY4OK3TCt^r-|d?k#AHv)p0Q79$$!Th*b$8L7 z2j0%>l}`gmKnf0aJbMAeOSsm&FprMvCg#usC*^`@mR@sm_qDYH)pv-5~40G6Q z43nNOvf$R);n-JV6r{dA~SpwYZY;DcN)KZFkriHXvA z|B>N~V=Top3n5g5I6(r+k%_n{)YP)sG%4?8L4$(r1O}@Tn@EPtm33R8blhQflZ2tX z0;a=fF{l4}P5354&)T);{}Sql{WLPh@M;U4kCNY0aU{eAomOX1@c?8a09>gNY{_6= zjoO;!TFlm9(xHBJ8GVImq4%4mg<2b6Br;h~ODjtvFjM&)TCZ13odBjGf zS{1-iqAg4lr72*M6=^=b2Oue}Noktj#4>q^Uq99*7UEfqe+$1p*(#3R3Z2#bcuL^LXTdq>1U!k8xcZ8c`iu~OP2 zl?&#g(eqBAZu*Y|tr65@eC5uyi$N5FwdF-+&9?-oMEQ(q5j0jxjS(h_9e~4}F|!Xh zRb&hhivU~TnTV;YYYZ=@=6( z8Su_w!Mp0ab?7Pk(o-nXjQ@#jVv)1qs4rN{RynaB=!dU@nt%L5Nkc=Ulq04T&@pjx z!g)@>VZ5{KMQa@einC$s^|XrN2fRcz3)6M^i#AEj@9LZ8gTFAcsWGF4?bRohtdw-^ zI&!flNxBh|L{ys_bkxLK&xW_$civma#V5RdyVlWnOZm&0$D~qnH=<2@H8LJYyHZ39 zQGC1GYV>r%SUE5*$uaI0%hP_P{hNW$mE-a$!xTT~l)7HnmoFkhuhf9ye-NtXINEtu zz4o;B+Cxuomh+uSIt3Pll|%KB>1Y@7_!d?{lq4HIWC$ z=ktJ3a|={I@zWJrfi?8bIz4d^HFExEhA;tdz>5iCC1XY=JYLU#Wf)$5wND&yx67A1X%wRvFuzO_>v9$1*G@ll@emS@B zBT${RHdxjp5Qi$yjM7$#Ut%qr$0?^KZs)@ma7} zN6v^fuoyrrI@McG;pBjn8qli;?+j~93vaVvhU$H=|ne%m+aE2=h^aDv|vkMQh3#9dw-dG76!T;@44OYP;ZZywcW|+DCo_WIcbU{ZOx@ph?NJgOG^uDxw<^i%5q0 zvm{}Ng6M4BhL3nVuktXhxkmoWvZtIrOoZtbtBXg`Vz z4xFW|3F%XlU1D&f0);zAYY?~SI%;N@(!^vE(iDWWn-MszNac@10|BA1mP$!I*n89 zWlj{!)SF;V3_(BNG}G|6YV0}!9)CqNZbb&90!Q{lW@l%oZQY3y#@(~6_=BWy2t1=cZJz6xq7(I%yMTa zNx#ZEvZqaCO8>BAWjB#$lW0QP@J8x!+y%#29-%4!W<_e&wO4JX+afMug0FUGFhelF zKhx*h%6RwGUYm!ivVMw{~yC08*y`ZcP)!-fAEH*j)J$Zj2rlzL( zW<}E$S4;NA!g;AC8R_JZn?4Fsu`$-#h;GWYv3_WNxmB1Uw?3-Wtw@C?8S^$;6qiO! zG<1cD>F_dj=>A<)KK5&>Z>~`YC%!pKrrfsT&cc`?XN;Ssn^sXloA;$rz1e>EUMHPC zr}_jdjRH=GjGYJ08#f^Lqs6fVoS_j_RgH9ZY;W>htnw(km~yTI_ptXB`^3f8i4IoD zwngRO$O!5pMt?$ZS8%}9=gz4v%9B^tQMhQ}>b|ns5)_fbyJJ0a* zyt*9OF{%ZA$2WyYtRUyQZa{Gyl6(J-Q4=f+=>CH{Y##{4oDw5P6c8ZaSUVp5Skw4( zIy+xL_Aut0QI!|e-N^EobKl?1a7rNa7%<>c*^e$-%foIOq{PlLbO7q6rs!|1reoV005D&(3* z^NDnQ&oVntjWLMYFA$$ie>g?QaJ)X{Yr?phI&ZKNbKr1s!~o9jk0D-bh=#Imn*O>@SIOA{&ykd1j7LqAH@~;5i?c5cMcP{1Vwbtt zc`u zwIA%j0YOm}KgYOzz@635K#`T4b4#ovEOSj)VpX6|Nd2QcOG_RP60rR8J(X{xE{#=) zn<%ji_eXV-f+Z)0w8j4Wc;7O*6bqU1Usl7NyGXV{2LejUDr)R_P6qKNb=|xDX@%$b z(V3zFap&;&PGH$y%5FDtqf)+dTmF4XOhO`0 zw`r!~l(>fxX@-`!7r|M{`}Lr7lR>rvp{gKG2o}VdeAoTW+KljZNS=gN${%SOTCVX( zDY&T7kEzrOa+Rhilvi)NI={a1xvpCeRgTFNds7aUlM{aR%0;*S5HiJsA?;vdFHFz$ z-5sNkOTK97ojkPs_&&tseODQ_CztJ1+>rS~TCKKxd3xa-Gure)#~+^eKbAUg1w*k= zLY6t@a_BBz`L0GPkt=Cx^`RSBGnc*}u+Ro1NhlTiN#k5_}m&1sz!cYgy;I2eH7M7~oXKkRIYuE{{`O?(8noQKvki zF{R;+DnOa0DUn*eX3}9UOjLM~NM~Wn4zDI@QNiO0zN%*b^I=KgY_Dx)EEnKg0H#3(!=zCN@T*SaH7q%F|SZP016GkjnFZ~!p zBoL`&CgSq2l1K5dg8IVW*85zO`(HQvXK0$@6hYo;%+WTr#9iY{$*_+*@8|CmhdE%W z(#o69Odl%`xalhy40zD+k6*99=S6ubV+LG_ngx@^xuwkhYo;Gxej*N?@Jo)_;ZGFhRtwf83vU~+7;?hw@rZA> zRGE}el0|7ju&aJXB?0OMLf@1vYmv~ntc2qKya4-YlK(rplo(8@qc@$Z z($cS-_mXyKQf%-5F_PLorrf$k@-qdB3b{}(`lLwTI)5Ce0i)yJLlmbm>bWU-)lU?s zGC>o1S*~s#3D$N}{7QPYGV~IG$2f>DvNzY-*eUt3qVjWPyv%3TwLTKQcF=Ob+8n`k z7f~tFr2VpI?_AC#WAB}3?fg!Y+F(+tj#+pzh!X9G4lkZ!vkg*9cZI=MP874{XyXm7 zG2TCQ8dX8m=zM)&pjsdHX1Bm{|%kpim>fz%;$VTv@s*G>5{25O@RAu5AzM2L;6ca1{ zr+KB!c^p%21*r|?<;=y_*dalY(;()QsE6k15UfYPmJY0!GK`xHnz5A0p%Pr=3<>h{ zX-K?sv%9U3p-BoU3HdEiwP*=R6=ZZIyCpLl?&TT)6#KM1TI>qe@l!xCpBMhOwsPG8Z04RZrdVvOqB9j-ZZcIw5AR)fN>CK_vt(Fui z&hM7$J$)Zv3qhA!UANJ8fLDf#2F|0OA8Wg(!jT8%7u#HiG*3gk$@4mUbWxiL#>*0C zvQNQxNe%z78oC8z*-J-*aOb?w98ws4`Dr=%O;va+Jf#BUma62Ib{8V>$@sc}Ne6P@ z3-vfM;V7)BrKPcS+iK%!Iu@&8-U4f4;6s%_d#-(bRq;KHljE5XW;xCHc}HhLtf)!C zrn`~^b7IHYNJVdiRG+-??!l=e=&X!-)vHP&-w4341N>d0Qc0QTi##<>*I2a| zY%?6FR5luEnp_HHn*H^MR!Jr%gBysQL%&?#tt8^i+t(cB7G0{RvbH5(#l6LjOcU3N!a6J06geahXTs*fM+_1NpdfptJu-li`bo|9}we-2#VpQ@|NaWG?O^d9I?aHM-5!xyi}p zoDQjzu+-rPUh5dMw6x4z1#reFh|kkR+V*&*B{xwkN~^^LDTSFz4gAM$SYWX&VzuJj zHKWqDQx@~747RKm=uMKoB6?K*^eq49yo%qcq4}js+YEy4H&``Yo$*N}asp1yX#f}X zmQ)*4+;Uj9Yn5Qp6M^y3B2q`RmO=7At_|ATB#=D%H zytA0h9=C5^mRjv5J=Bfqy>N~FKbqb;DysKuAC{631SF(eKuTihF6nLrk?!se>6C_{ zYk;AoLuqj68gW2UYCyWA;degY_kI3lu~^KUeeQejtMT%zfoIWg`DMWMd;v$ecUMRBsfshJtJ0p1l<}q7 z9K>IpD94)|U~up5_cgqFXqDRU_4II}?57eFKkbU3eU=S+#P6lMrUla_l^c&a-p2r!N>)rf4Z4)EJue;x8p*=P#>}V~8sagE;C!=Z)!)x=0EG z|6)IGC76|Kay0q_f8zSF{pPCZDdJub8Ub}cmsTXWev%oA%=f4Ub5+iTNU_Si8bvQC zXa;W8s`voP-KiM*{c$-mY1;7AN(y#o@4^0K^Y+JDR{MWZ^FXGv{$1s{rZx_(5hn!qN0G zDO5H-PjsBr)M*2Icf5C3EI;iLr>hoDPPl4%N)SFfX#6oI9kK38Uz25q@*4=`Om*kn zDbSvMzbGJ{^Mjd{hs7&V8b;ED*_j170|P;W`ksgcu8;Bc`?_P+AUK1~63}V6I_XlN z%TIsjW+Nsc77hogk*~cXi3LMa)hidjZSo)8{u6vljI(??E7}<}Pr{G5CKvG~Ku^UC zw>rkE+LmU2P3+1S9fF0zcZS;+KkU!|_X4%irTHVKJv-DaYd11ZKT=-@IDdn}Qa3>$`SD z^gnvz?a5JfmnG4CVGcd@OZ4N7JH|X#(P8g5N?EO;<_JJT?^LN(=w&7CHY~1ih z4x~Squgod%M*gGUqwv3@wFL6!+|XGIebZp-&L8i=VDQW#85HRBD%?$Tr}y;O?6i0U zWv%&3?JGIL7~)eIydke`;!#_%S;I&l3apJROt&g6X8tr+5w#@=8!iRb8=dX(GsGxYha zoGw>KQyH~f#=A=G>e&#y;OJMl5PNfDflMH!Nmv%t+TwAuZNM$!Q)qg3b$V6<4CQv~ zXX6I$^R0;4l_f?zty0I08i@g-xgo_!^g>!w1N=eI+nsZ<>+a*Thrpxl`l+|%Dbs6a+e-rr`)Vb~J8oo)K# z;K)UFg)UX`i?b6`=9Dt+Gtp>hRfl?J{Qf#-niAvUGeSIlElme69fwJCF~G;ecDHTpd{o9U{VpocR}q z>=;p1#@idW_y5(9ZSaf^sxMe+;HcT)RR zWy$SQk@R}g^e0x=-_3WaR(rE2-#Kl~o8AdYdVnpe<=6_$`%8x>KD2x>@nr8o@`?+` zA@5ozp^*L7QOHZfw({Kxj)+2JX>^1f8wTpwFzOKo5wRM)R8>P*=~5hj(wo3s@k1bs z;Of^bO)N0jLnv8RELCpYsw!(dBVNAKa1bLZ&E#GjQDMS1_O=R=stDnBPH^ayA&XvU zOM*}WlkNxyFd-LATELvtQxds-j;OXPvcI@Ep%QApCDHmaT<)@aEgc4}S~x}Tg79P( zWu%)SOajrA1B_hs%n?Rrfb=!~FktQDKlIBVUW;${1i)wCuLBbfXXnAx;BFn4~1J;6;+n>^}xJW&)T zjaYji{^?FNph;mI^t80L^)t8m{?F@2BG1<*kd6 zr{``u8p7j6Z3-9my+!}e+_*p9(6kqobgDAjHGXddXM0YV+Cb92$i+es>rUy1XdX~L8vktmBff5as zmnp2tNo-mk?p2$UWWR{@$-w~!=FOU=Qcg*MjY`|Doq51G{v(z}D$=k1_1>;GG!rLz zzxXc{)C>oSbagd4QL4dr_x3E0*2VrEEDbK~l2uOU?~Gn*G`qu@fu8_2yP6zP(9rt# zs0pw*(!=W}NlF>^Oi!3$XOd$WjV`oe0*+I_Fl%$j-Z4S~=D?Tf2@&msJ zT>-`wSJP~dPF1pNJ8-zm?iLFRxw!B1@%Y)*MR}l2tKTG0Vb&rM;t!%~HwIRarH%;@ zp!c-QwL1~(S$hO=@K$^s-2u;fSF2D<`X+l+3;|3)JpV25962?Z%rXNq($q*Su=VmHUb|8pN@vn}tG!qYa?`RdEJgaG zo5#8s@n_F+v0T9=@B2@{x!In62EdgxaKw|81vLDAN_*7bz14l3_R}1O9?(h z3LW=K7#?N4YfUw&y_0}+-23%JD0#Py`F{ERe5qO| zDin%fP4m9L=Yd}koA=G4-Ch4O^*x7EL!7Enn~GCJIz&t!f7?x zvfNtOWKt8HNoA39CeCbbhBpT_gsh$ncm2rSRmCC>MVQe{?aHQqjQePn#+^m|DDwb=wx;wli- z-qvJ`^brudqXuFsSR^m)d2>Obm)T|;dzFRERr<4D1<0bn=uMX7 zQ(Lop9g!|u&yA$P13zcctL0Eh#!7{)^4W8{iEYEc!^_(4JsS}G3s)QJ@(5^P#yjza zsce)Kxq_&K8dmH!XsK zrEh;S??<2R1e*%#-z?JO%A!^(&wI1#LqYufN}Kd+jB;bNFArB>W+8j;7EbQpN78;7 zE#LclYbYbkz(hai5!p`5hqk3lMAB>iM=~|LdmY{ zNPN1!kz}$NHoDrC6}wm{17>U1 zt4rC~y3FNnA7ACFQpksUF{`l^ls5DhQT|#TIx-dY4;Xx|{u2K@vmrRiHS{=eIcVSc z{@ZkL@>D$+0ER`jtCIUMdUApR|!g*G%1crQsg3`YP51sR~Xkh5fTX^q#Z)AXhaGtL+l?FU)+6QWCi zAv^&`9Mj@gVt7eL0YLoG*ftr!L;x#N&No!vq2aU#Z@r}OsDh_H6x6lK z*1Cen9tn`z=KYQ577H^uHRYxS`+F_~Zu|iI(#P%JjtwQvH8Hv(vK89q*SmztRFdkv zd4NBn)39xF2U)ZY*q_&js^Kl|Ei?1;^8BU4g+js;Q!C%d7MkKJRI+E6;IfX6e3c4Q z43Tv3FV;uvRH}np_ql|C{CG%bT1?ixt8ckqxSWq%d7Bp&qw)2q+S{({2S1{LzF;z~ z2%H8s9Q0FYD~$!!gy>c=!|g5N&`0GW`mPqceenTYr0Ctl;_J?TzxRy-?+%&f?4wht zHcA3}fp1|&ffYR(LWu5Bf)CZBLYSYHM%_>KKD3+o4yv{IPTD-^>|dLO{$sh%(|Dvn ztbKj1_nIs#iGf&kd?0@5`ePWhdZF#1-aaP2lpuk{Avu{&@XVZS0|O-zc*YLbTB2_>2f$}MZtR(ATP2i5_0QTd2Ad>-|2+*ATIvBYa8RY zh{)HU%wFiHw1ZxMk$Cc2C*rgkSU%r7q5_X^XvVod4)m?hh_0S{-yTlC3`c6Q63;m2 zsfr{a@6gQ^J9YnDjOx?|9uWSLykYwG@90gYvis?9f>Do?r1*@;#5L;FCZ5@U6cE6Qgc=f&OoZ+HhPxX(%Qx&A>4mt`fZ^*@U`T1e{jB# zM=X0oXEeW~gz8hiwDuk-(<4ewEP7LfOh(z93O491zQL13+gMSxi53=sVyr;jJ9I*Y zztki>A2*y1G+F-+eh)L^OHMRX3R?UXsR5?;H0x}OC7!WuhNE594OE3(V`+EkhJOJ8~{L0OIjZ$!1Hm= zMyflNc8+%D+hds%h2nX`uQ_+FPc4Tmd6*-3{Da1=9`7-n*4hf1ZKs-C*CdRMe~(x- ztE#J>{7y#v*L8gU?AdYqdtb3)?qH?8=+EZhM1f#--mm)YF~|DsqioEp^N~UP=F8!1 zzoSkh;0v?9%rq$57g@XBX|Ku{=lIwXo3iX9+9(&n2_Sw4=ajS~%Tv5ZM}glcL6}(pk?!0iq4E|TuvO>iVYcZ?2XD@eiF3m(ONJ-A%H|POsJk%flRYtHRe88U_6hTM^euW_R9Qfn96T zFHB+6ui_!2LL_jeSO$%$IG z{6qoCKZrt6t2^WXOQt*uqjBVf5~dRovBoQRGVqs;>Vh#|yxXY0+!qeCi42m!helZc zj@1MRGhX1tuU3urKi?^${B(VR_4)JX<(t{1T)_AnU;5P-@e)XFG5;9)Kqq>2 zup=wDIy8^?7~>2M+IBQkFwm>-ap12psDpG?WCjQNo{yBJ@CZmuK}py{UIUfxed-0Ic$v^i*TMTgkWZMQP$T?679j$ zu*HsWsm*n>g7br)H%$HGVp~$ma?pz!eKRHIB?95i&t|E*7J7i0@yOe!ACvNb5}A-V zb0gB^*QKmD>I6*>+u7Iu1dlg5)!w-cZ`T-l4yxrqCbl^A$LN4l{g;WQqmIV5LI#@5 zdf=S+G(IX7;tfH>zczs^E~Bya8558!OQ9m*cK&g?IS7O<@rnpU?+XF_&8x^X8?V!i z;bnIu%--?1*yOGI?u@kk!ZY0(Jx$`BX){GjOGYH@$6{lkAn?K`nZw+mByGnFaXNK# z%NdqO5yQllEcOmgR*wTw%O@rH?x$(iLmNDDWOMV2@<0OmQd@5{?Q^W+&bor|M-)|f zvCttre|%O@2)|O>Vy&?IzjJUsUz!WZDCj(YjXERA9b+XHu2bFg*oj=Yozpj765Rz- z%pF?ek^aYaV7_#i2)v{y7lc{z)8kfpWFR4XP7;)IxMcPx@M<+dCkJ9u&#m``Q0RS2 z>|IX^-6uD7$)`W~k74|RYitG4gj-;W&TYo_=1=`WkBFkDx1qO^kCD?sJIyAZgT}u_ zzr`*x_t0A8GS_eNhzl#JC@g*JS#v029P`ht?*m#LUXL9rU>b?X^0yvme(Zg^dbb$3 zPVh7x`p^K}qDdf-6=6?`3x%$V^+C>qEY}zB`-2iToTQ|r3BV)=XSDU(O^xZiDWhd9 zjAfMRzf*foflmLCO#4y{Qu(5s*Penh4>)fv8m}rE=P-oE%ih63MoUk57&V0MatjP8sfrKs36OZdmGy`I4nv@jyA-%l;d ze^$kh%0ADAhiBB)C9>G=D#>U&y&=LCXB9nqs->PUlniyiy};+TouU$(mKF2@WF?Jm z{bF3*PH#^AUQJ&CaXl8Fii;RyQZ(I7s>#)C?d)9u+FlzBX3kZH&n(Myn(WLQm~AI9 z#ux$bMbYg~*SS@m1iBM)hhsX#?;k*Lzn{lS`oYq->}^0P)u^PP(`qcxLNn{_*g0uA9JKJ}ly0MWQ_@R!c!Qi@4z|jfz;MDHj)Ya02m$bRXd{7(AyrXPbiGt)<^Qw*ev*CFUAoYhu>^3CQpFs%it(9a^wcO3%gN_3 zE0Mu1tHN{^^)ITGySw@Ft=a=uXc9r2#$3Jk9=dv)>yO<|zptq_)6?^5#iwWg5JgHW zie$N(@ScFsPHQsYT5ly0ZZG6!MWO1Nr0BAZhKql@o)UbDV=4ML4Xo7r@pPZp zFe6?=B(L*T4UL3VRox;_zgzV21uBNL!W{?jzhw+6tga6=3g(EqN>D^xtxRZ!?^(pD zO}nh0{P`U87ZFm>fAd0dfs_GDs?Iexq>um=CyL=FsL<0^;d=Aw9;5AeISN{3;(eL9 z?6+wQ_LwwmBuhTt6nz6)>AUJ?JyY&a$hUD`3P1{KKhu*ZL|tjx&0CT6RN)IDSl6%l z57amjPa9<_3EQ*K0vo*b2(VpXUNJRYI3;tLM=AM95d*C+%X{7hNgd~JcGy-1@C?|L zc%X2w1sR-s;hQ7owDWST#jc6>cIL$2qmsWu0D7MjF8n!TOy0+NZR$d|@csf617K*# zQVF?*%{IEDuCYjFVyeM-)xdck=!F{m9G1gQ z8>2!vsCu(j0+eYI{H~8;|Be?w>v#+K9I#H-)d7qG?m*aMzwktXXtsrUd=B;I)(JOD zbj)Jt$+NqEhh^H;nr{te7+4Gde9VAdw`N`uMnN|z@djg}I)j{69Cp3Mgu^Y&Gun+W zo@h_T3)j_qo2k-ajj4mMAF+yM+3@S39fo{AN2PqJw4$Hl^k3HGHnp4=kT5{n#Wb^{LNRmc;5N5CXrPFFmZOb~$jOB%>X9)l>OOUg;m3Xv9I zQcL7ilRw<1%_TT>6P7}#!gO7*c4L~wWu^|W!K|oiTBlUmejL&Ei-tUR3J%Hp*NakG z#8?=)s$h-azkJKy2*k}%d+#XnaS)livhr{)(d~;TpE~^=Dd56%BJ0xgpbiY=4nx-f zK#wb5^0%Wl^bEVl9U<9xe2F%3bhL8@cpVzgcs=Us0Aj=qN(PCt$@!mll}S0HT9}BB zzd5;^+NR}7Mvo2`d*Ip1jMkUQpVg!8d#E(RDcR#BxbXVn-W-Tii+W-b;d6Q)j^xrR zRxDLhG$wY|%*iH;?QN&UrYPB%m!4ZA=1q8b2dnKVfBu+LP*CjUt*EdS&`)S==#TxE z_xFJL&vSRi9Gd)@q&a6w1JLl|p{AXZWqOeFk;) zSCaPxg~)NN<{Y(o_YsY)Sx}On7$7(R{BRW3g;V!}>3P9_jt97LotBt!W%C^>b_#2- z(d6Mke20Xy^C8FbKel(>_phd%mPZ~R?rx?-FZ_@0=QUnwFtHNH??xvxhjh%E!Z7jw z*R@HkyNTnk`8L+(Of>4~jsap1Yo5bvU`loGxqLV_&m}c5^CziucAhO|*L=2=CY)~E zVmQt5o9`4YzVwsvPReqz5hM<>f8CR^--TZCCAkvJ=DCE6CW%#!{kilR>LAGKqb+a} zv0wKnl;{HbLdzTxX;yER@Gwmj&C-#qFE{5q&45MXvqDOfB~0ByKd}rb7&f+thlh)Q zlPK~mlDW25g)3q`M@q^SuafYLZUX~Ht$25%NBak3a;a!pE->OtH*Qd%P;;`T&voy0 zxhst`)dwI-I$R1|*@HFu*iit|F0y1hsz`_~`&qUep4;y2*8QLMOd);1xRN|quZmT> zjQBZ9$uUvF;`M)WMX!G^-8>=TkR4K*fGsW5HA|r347!CESlUY!RpxQawZ~RLM&G&!t`tG3Dp0x+E$UqJ=#@$kwj>H%H711O6(#q!JqWZ=mEWdf+7G z`j+7*_P*1E-sZ2}tnDw|Oe+zkb1lKaff1i8qyeseZ4g1#XDJTfE>64wL zN-O_@aCNe$vcd6KsGvq;7+2f_3NuKAiB-;G3d!>s%eYjeVBA5_|xO77W z=+ra)#FCw1R`pG65BNcnbi}AIcR+Qj+LpRk{U7J`3Ij))^(2TEb~(b74iapiTbPN} z1m^iQnAFoVBFjzm%X(T49 z(^+Qu(M%DudYPJv{z>LwR+%v?F$BPw`8(r&Hjz!w$cd!yVk>aTJX#zgat9FQSlGs# zLZA1n7oHm25#jXyg~(@atdn4k9RzPu2)F zL94>mMu2kt_X9XfjhB{`_(2TBc!W3;u|CyR#rE3i43QjZdh(>U=5(j!aiC%pSv1pt0l9*oc zU7LLI?mHdlA3PP~p%+q-+LF}{WYJ1&1CU5OJNyBq#vb|}))%kmeH6LYR zU?ClrVNZ~-3P8L8ca)ujbER=zDT5UH**`6Qd;K?bC&4BN6g?J6kuguoU+4EfkhwYe zOo)Y%^?V75?>mDg-Yb`&_EsgGQirGxXM*Nc<;0BBogc7p|gXZdfH z#OxjwCOO0Gr}%j@iw0&uUZyDWZyp(OW&}fD;4lzhhrc5yD~yScD53N#L}S&hdD%nz z>AMQ&SLE2v%!OCDA8!%?&bD$U(ICq;kdsKsTaAwR*!z6#QgL{b_4{I2&1PkaN3{%x z3!kurv{!PpGS2vWvt7F^aqwWhYZys^}D99dwV-)!@prHN$c%u&M7sD2* znb~z)0D)1`SwXVYL@pYdbr<4BYdf7^Vi*G7Hqf#DY@owW-d*7kiE0ea6Xp+!=#-Vc zKk9u79vG=ak!QpW`Y~Nlq5U>pv7*9+0jm`E6Pl#R(USOQJvG?}+o8MMR>$}6H@dXT zL;zinTubs{kTYfIEizO(Bp_bn;a~3{2p1K_kI%pKK_D~gp^le#0XwJ?reUr+uz{8f3FkIIwF)4x+nEQPg zAEPa+0rgHxi*^pzOpc>XKmhnO4qI2P@>_ErWXI-yhUJ-N=7^$9_KpZdn(W#`+aU*l z89MufxlZNM{5_F?BwZ-@7F4#m39O6FG7Wh9@PM|^NCuop`C{Jj=`0#^YX}&a-_g)> zT!A&arYdp^)~>^rsag8ghNF-!HO=R`%ly*fq4CfhI5jWqwD&W z4B>hp*PueO+s2lXfb+`0-|=^q)fG`*A`gY|gh+ypdA9h{nT4N2{03$!yrh=LJ>B_Y z?rD!bA8`j62qak715hGYMQPp~18CZhHV9u;*B( zeuPTXwC0^w?}#Qbw{8^om%OW~#o*fRZT-i)&?i@1ys6E9qLR`f4q#p0WJuqZZsCr} z5p{|$eGTeXiy09`8+BQ4Z+2n5I$H%VYs9}~0S`4b$t=-22xUhmj(UYMZ^7_o5TI?x z+b{ftn4-SVemZ}$8GSQ8nvyh|qt1YiRdFPJ(HsG-2Bhh{>E;1liVT^b&ZAjwzV+UH zU<>J+2ZCJn3_cF`trKJ_ldoMl63<@!ec)vGc!t1xKb1f14K3$0G8PRa6XhFNH5C>1 zz6F8Jfk47A$eu1Wrlf-^8&qcAz1&j>Cs{`x7=65^DtV zpJ@e-C$^@5jUht_jQSR%#GKBDfaU>YD&T_$FZZ1y@ZoqFKk#$Gzvps;^q1>GU+Hi{ z=Xr7p{WDpFV`3z2B{`##GLAW!CaY?CEQ?`_A5UGKv)HX05nzPen10$&!M%9tHmKlI zX~=5+x5>V)n&5d)&?=dYDdjDSbg*|rSu(zmD!kl~?N7{eW{QvN&7srkJr@R{N)y~S zTMa>Jx+0ScH=Y2Y(=xLCuUn2_IPBTb0a*!_kVH@--hL62Bv1VDjS%o?CUPp%@nw0@KbH&yg)D-39;&46_z`PyPU#(rSW-6o0e6@Q-6>wga>olaxbpAAZ zkHM6#1ZYtTk7vI)(`Bmi@JRIk;>>%yb-uupmkO_3Yz@R0^*Jcs5W)rAH!~$@p!Rk^ zx-hJb4KS0ffr9uU$1eJ{CcyKhQ+wAt(StBUp2BE$78)6O9ft518a*+mT~|#!37qWg zGG5$hn5VG}5P5{`^77&>CN4K#Ns!{*A0Nu>0~rLV@!{N*Irkxzgh%ndLtNEnxPR$OeP}t z=eM^xlCCt_W}ejMpkd`V8+Ksj5^l~t=hP6TpK)!yGgTzY<`mr~Xn#Vi9zw{6Pze*uSOp1+!W zI8_{J>)ya|zGcZJC{t;dlEviz!DXI)MiwcZyrQ_0G}Smax%POv;s6Th>LbLjO^ImCyx~yCU0$pZNB@~(l1hu(eD5A3$!9a{1g`fQ?DH9i+;$NXLrmCLy^(ffY z*06|*1Jo4=#6Q~@B3l3>MR* zZs&MW%Dz9b%+odzOyk5L^z^mULPvPl?Q^bt(Q*8be&N8po%Qa+*exCZK-M4Tp_$RG9i>!C1V{v6LvfX0^ETFDFRM%I_>j3Ut z##~ixJ)Oy!^=HR4qRMQkbTk^D7Uk8cB>U%U5GPJCp2&9|e=gpNh-9a!GAr540me7C zi(M^>eadRrD%;IlZ!fc>o$EdL{gvdSEU>l)@bTeD&3Nv;3Vo_`9pw)wq`Hxsb3`+9 zU|7aRtB|WO&;#5utXrPfAsJoK?|V+7%=)e{fZ2?<_uspxH%~lf>wjQHbh%Z1S0-L+ z-?qVo=#RLWU5P1NV@03Ht(TE*)UV~yhb-OCbZuZQqi{2R#A;XW+Z*yQ;2* z{%Et_aBH{a0F0P|j3s{3VI@^U_2Zt?4`FDSFTbcmSPkWG?_9sStQbq2Hm0OjSC!k5 zY~#k0)03tUr3{}0)0$yzoJQt*V?VvwI3@r6)tN-8lCSndb2I=FK7an)&e_@gCZ6j; zG0}u8f#7S0B{rZ#*ti}g61y6BK^1rfXi(7MiyXk(f|6=Ngbx`x^`EU#A`Y`zd4}Bb zit60LpzuwYM)6;fyf!EErGEt`y+Kj!YyL6EPbV={!al?VeuWxlPk4)|LA&NYM=Wyxff@WTR7d6`nrl-faB#Z#Bc+mwp=mZOgXsO9q0UKYyLF z_ujsF{|FD=aqT_jNK#YtsyCEoE|8h+OI&_D&tF+&)nedR)6_B3uvFnI-2dapm8%Qh zb0P(BmWyjl=pUV^P?g!q@Ei5P2+Y`T_v5{+HFKyga z(3rns#E~RGkAE+ay*bplc|S}0K+jkP?B(nL66r!B|AIwKVA2>t=sn1?Tv`)i=l;z* ziDc)p>a;Po`!K{>KtdU8tpd^&KRfFl9UX1-^Ve9`R+~6#i*j|Hu z-cH176{V$Vx@__S*@KC4aX&VQ&xC*WmA93oLVmn|Rn2r$Dld|2HGH-Wm?o@^SaE(L z5Y3LTmxXtK@cs7>+dD(LUz_UW=7Sk@w3PJJ_~mP)%*<$~dr!oA4RuuXyg6(1>pwlI z+zET_(j{-6ENTRUTPXzqf~sGop=V$T^QGJ6t@qq0aXLIb5jTlIgBc)?0hRg{ed%nK z*b`A4`CY51v=Z8Yuj$3i}HvZ9*Z!FJLD>MCLg078MGNvby zckFsE0{CoL#Cj|Q0MUMTlhE+Mk1u)4`prjDYP}PSaH0wohaSWFNMD=jnM}N{ME3T& z=rK3Husm{3osFG62MmTZw7;e`{1!lxB7TomgQ%C~V+1TBdJ}wNyaQ>;!?hpUrJ)D@ zG_!_@dvVyzEX;}(X-+2X;eUUN2n+6XmBZ~{#i0+&(3G&&8nwpPiTb3*vbfhW#G}T^ zMQp2x5;7F`K0Oz_y&ZiWUu!ZyY?&fH1?&W>o+u}$peU`c&uVKEV5@N$DJKGijr~nk z&{``*{Yp6-o4uV~absg@W21Y$N%z?9u8@vSI$&`)-_r;M7ksZt0lFxwX4L}Ks6_jaYH+6eF=TpS$q{mGSCGa zdMOn63^pqM5}RT`M!h+hxzRAu4isT7$1QWINO(=w6@UEgEQlBt4svsT5vhB58H_*3 zJ*$hit z15lg;_0#u!0WS{UM$q-0i(AZMF`UeRNCs!H#9qrHB;5LI4LLNufMXOnH++8oc>Ktv zqoZ?Q6MDD*6YUZB3KX1J(zR)IHV)v)>rP;$+(OLJgq(WdI zrP=kybaPcV5yIPz8t|*c{je-?RIVa^#E%3*NTTEPCeDu|93b1a!^CaJDzD07s5ojE_hkd;(gwF{9J5RJ0Waa!dd z=}|#QtX;+CJeMCIc!ApHx-tg%(3F^U{0b9}JIm+DjXxNVs%y9(2D~d990cy6xz6&> zl|@1EbsyS!dH6@YBox?EKdp3m{}cdORN*X|yqv~YWFl%25NviDRwiwK2Z8d+N)%PL zHx$jLYH`#k%36x2NS*;TeF)h5qRw0U6G{7nez6~41-DXR)))eLu7D&}mNY%gjzc~0 z&LW_}Ye_S0 zhKc`u6g=-}*c`&xgG`;?j+0~TNKPX7l(S>15vxqf@T}7$*$y=DOAYYyIKL^H2712t zAd0ez*38@J=Wk(!>>Gvxr+#UbG=cfLB5DkoX$}z#bVcK@G?@MEjwPIyAU!4FeV&a} z!oE7J#8vfm$Z&D||MIiua&ZayWJ{p-O#Jmd$=2fr zrFmKwgz01PI1c-N-A#o>JFS#h2nRn+*B5jo%SzNYpzM#gUP{=V%E_jowV&ro*k)%u{75=T2j&ZYz9eBho07>Nx^N)giKE z(y_;tWtl#FVq7uwr41=qT4wsAXlA9A>TH zO39nIkMO655BKfwo+O@*1fMjZj*ivP+KxldEP?%ABFRbtt~FJg5`a+ephhw4-@p9o46F@75qJrTyd zq^8T8K3)HeKiB4m{jn<1QLYqgEAi7Trv=-XDG`fK##a>@^srC!f9J)n*Cn#NxvZ`H z$oMSge*PTTm{Q+}L%&%DMH7}ZHilQygaX6BsIIOi2k}-F26LQM{NV@Rnbz+KKYl!K zg6oiVMb`uUzdsO-KpT2%=|o9W%Ag~y=Z(kOG{T4~t*TY!>R_|>IdIR;73M3hB=71} z>^M&`VV77LoC54N{_=9uioVEJYo9^lYS9+hXbl75Qh>p^;QZp!rnICy0UaG9HP_?+ znm{bnzmycayM{6xsRNhda_gHna~m93sH0!HKD#tKE&(+yt2Zl?(3BSYi4GkM(K7u2 z+td&nzHT<#ta!LvY&6GHG2mbUDh3@DNN|w7%LaB1va%FgXSnyu3g&>PHZV>efMiNW zSn~P!)3rg>lb=dwWenr%bAx_TUTDi&&-pCM@F2Oh>`A`l=ys>hEsJ zI_M~!K|C4G232(pmGvdkQ^kN^`uH8Y5B@;zYeVhaGlxP4Kci6DF)s>rUU)A++{8`d!AJp&HsYI5>MxQ(dtabq37;k z;*5@Mzfq&(Xyx79tJ%*;|Gr7`AGvaPF1dHzQB$NoIe#Gb-N$$6JqlulIafki&YubF zz-&oNgdHC{%#+@q2IB+YaYi0S@tki(3) zV@jCLRt>OhulH`LcUbbq>=9#JzgC7MyxiqOn~7+I6qZG!T$L9&!S$SjJiMYf0Wyjj zC7^Puj}?v;WCHuqmS6`3IF{=YH5JgSVNd5Xc}m#%32L~@Uq3sl;5*Kqe@HX>yvehD z;8g=Qw7#g{|DyiJwTBkmlFquh+ULG?-&s$|*OT@PTo35&FnS&j5W?r4{U*IVH3;1-LgVvD3TnE-(6rys~b0)fMwKj9+U!9St%5!hj!hc3vl62>&|MKYE(j_e_5ZI z31rK%vH`!{u_9H~7Se8|NASpB7+PoAaJ#(y%>Jsq)qDdVhUF zNdl*Zrp(kh_s4&fW=P+s^%SGted%9L3$gXp1n66y@SpkyWmUA33z|RFGKgk)$2z9} z+(?{SMX;}kyx&xUI^GihF^qhvpc}Bn=#gyh#}9h4c^#8yT1wuZCCumIOB7%FU7@=9q6ec#L(Ln{bUf>9hq3{_ z`s>GP3~j$j*vrnD+p(ca+LT4=!%n2<*S^lbF~hIrwPry|D48^o{Sn=QaFDIY^c%8( z>w@BzMIGB;(taV!P0a4dZlJ2oFjz@(06Kvt_?D=g9eN%5w2OZ;Z+5G2KNb3D+UB~d zDDTY=uGe8D1OJPdxwt>SM@U|y>2nwj^gc+2e6H84aihkRbDM66u~y8;P*tfc zxtR6Bz7LBaayz-q_P?BLH=J7>?Fq)8U2ckPY}86?PAj>oul9{tTpM(A56d?|=&Io$ zZzQ6YTf{V!Q;JA5tazAmE{WUOTCAp;+KV-o_AEI@JPQdbfq zh>4mk|HLjZoY&}rJxn=5}$Yam|#Tv7w^ z8;=#LzS^V}89^HcNywc_kP1kon2oA?t-JE&r%B;MVgV?2=|)4Qthi5h+b+l$?1~`*?1-=H3=LJAgR){*pMjjs zgtj&xhkZ(G=?xlU%pDcthp)wCNwBy#uZqL;I0!T#14p-kFXG?)X~}Ci>>kZKzGF3a z$^kMQ8*9rCzDd=3P}{B|Hllb;=QdnPb0Ulyz5g|qJAC&Y-_Hqr>i%)CpJr_YfU$BZ=WX7%WK=e!*D}dQfHU{SwC{AT(WN}}$E#`&iPKNFs z%SJ6PrsUm;H5a-5$OsCzoajExvV276Sp$Ej>+_)ECDHr&bDl4=z$VD!70g}6tlfjP zBQNJTh^s)b=UrxGFulz0I#miS{ykdO%L3MdE>yt%gziGH{%v*QxjHMGG3&vfn3bQ} z?h1PR_Pa;^g5TKR5Y`5^%uXQB00bA{cbAe2IF5}+5lz;fx0bDdwEqAe^5mYayTod-a<*#sPYXYAByfBn2gQ6DJX`{jq~}rW(SoxJ{=qfb61`V zT|IX0U(@AW2@_lQGx-S2hxAy6>~cJl2Vx(bL={BR``u0Ted@OC_UQp|Qz+zsm0Bgc zge4v84P_fAt+D# z%BIU{gv(GVkyDg^^d_AJ3mrJpvNGBAUnRZIol;LX{6u=Iu4U07m6MVAo-HEGOCAGX z;=)a6|E;ZnxCR?{_5$uPl7A{$R+8)G_cbB+Zwq{R-F$g(L4wSartrg8n}OKX5$uaE zQ)A;GdqT;B8*d6~ja$L5Z$GZr39hb(V_v;VfyI)EIOJBlnH2}sah4_CQORIYA?QUp z#m^&w;lI?X8BPlxQK2t_apML}!`Mhikxg=Cv$_5)ox}##`t2S^hn}u^56zLZ27fqL zBt*HVUk*tg^>o5a>|DHiT2~w=LL^=1L@|u*I7>=qe$T0{ix4xj%v?<2dk0It_(FT5 zhEt357ix>z@5+J1VGZH7elT9fT7E_~ZEF#f)|g7j`~%jA<8LzkMpT^t*xgF|1uHMP z9!ZoPhcZL1h1Lf?{!2U{+Rkg`%Y`w9s-8T);OrY|26-(l{>!%WK3d`)%Q6Rws32({ zq5H7XV*p1nY&B=-aFo*$ZkVaY>>8|(q-g`f|_{LfeXU_S@-oHJL>~R|M_3;+?B!GJD=k&*gxkd+` z9b2RyLa;G_Npz*>;j2!;e4uD*C& zul4&Eycp}dGnrGTJ_h%8-e=rw=F`a0*X z(HjD(-L5Hw*a*vRV+1X2H?J#%QO@jCbt8ck5=xVgbK9=6=uEa z6Jzsw^l{mZP9<+lix|eewqLgl{)@9%xu;XSW4Op%2DY5c z>TsUxrmiDd-TFkb==-q6R{yN;t5%g&RbY&0?QNYN%KZX0e$3OfxMl#el7)3(%SW_S zbY^3t+0?=5<9|_ae;F&XILSR##PHPw7_wK-sKD3*oCt>T+%p^K`$RhkRXH3Um%mE| z<^s?up=M6!s)kQ~N^^Oh@*lJ3YZKp1Yt+{{8W3& z9bX|S>K~&j6cnhi5DAJ1)mz(<8`hcI`v&IbSS*eDNQV|FK$HZFO29CJ`FWC)qid$m zI=!6*%F|f6qVM0Wz`V89{{Wo8r;%snX1}IK9&h@)Ii1}qYHDJc)g}I1auTp%&5B_Q z&~%Ua;bd~Z6<5>R!2T@11%E(CYrW39Xq_SV?8KH_pP}oN&pKY2sMAM9414bo_pRJJ zp>@a6eQ-Tl)k#5=lQ6?!3=H5nxx(;{g%A_l{A+KCRUcguwYRAM^Bxm(l5B@sl;nKi zBO#UE@8T3S@+Y6s!^&p%iX*z$!L8U{#?Nx>T2LQt&^f=*O8-S6c>T=}Yywe0*%bL{fS;M_)76EH$EJ1f~IQ9pr)~i7`9YodPBDOg!tM2CLfp~ zopqW5guCN;zEVjw3fomt>VYUpqw&ccI}0moUQsTAqda9m0%a_7VM|dOZ{fp@tl8d% zp+zdY+2zOOt7Y?8C~->+*AQ0){>d_I^}gnR5-sBHc|Q-mfm@Wr8z{{tE9BsJzjE`7 zzyZUUX{hHah^M5_(wc0r#VmffBR6hxo{K7OGtO(fPI^hUc2lp*k(lLJ2ZJ+`kPe>a zj@Z*5=|Z9NFP*5qo1Li@C0`Rk6w}rWZ$21#?hWmRU}rQve$|on;%2_|Z&9v@n*E~c zMoWB70gn~0J^dZt0pCII-4}&BQvt{&S^`qO(@*zi@|ByXiLljM zsZB|7@}F0px(_6SZ0l0W1Sr+{DeI~?#W1$gCqFv}A)71!!d0nYlFuVEdLYd0`-b*& z+~w(P?85^>5)mp0i{&lm9bViDlYYJ+5%+`?6~SRm&czA+?nnKm7_iB;u}Kuazfl0& zsKJ&W$tJB&e+dBu6OnrV@LSrF8Z4OA3OdJil%l_P)Sl#TYO%oo0#cp>*Hx`XiuPL` zGTXI7@Sr5WKmqi{Zb4N${^sTu9ScKc@hk?KB;r&hK1M?81`054QeeRTZc zadEUGWXcSfkYxv3+c!pni3EBW>|{x6w@h((3}MHsE1WA+#6t-T*3 zIn?UG%Rh>ee{9%3f~kxqwU#~2l+sQnh0V|yF}NsRYoj<$Qx6z?&XVho9* zzfkNGMMab-BPLL>(PJQKbbrI{h-IGtAd^3H+x2>@^(r!TuNAnEcts%!77;w;Jm%Jp zj`52}1Yu!eUmk9r-7)Jx^);14B+fti{W5?yRDVo%>$n*E6wF-Xiw2!+pe7fvCQ4@2 zCGm87?WmwUgKJIrNX8Na-&@6Tks;`3>h=o*l+r{P(N$D_K9zV5_j=#ACkeKCWV!|i zEFX2C<4{xqs_$dAhGb08SufKy`=F%Lv`CCRjFf0M(qmKs*l>kQ)!x!Q%9+2HC5wF~ zy!Yqb&qg1IzYfxea*9Kji_&`(0tjy7|ArIH^5LT$e`zfbD89?J#kgdxGwy{ z6u=tvaq#f?$7TkB)kf577iZ3zaFSP*nHV_2^vq0@p-|?jPoLgTQo?FEs)r2Ts#T~M zzO+`b?kV>op?_ZyQ)X#Gh7`&3?Hm&2*~fPjou?oQxNr+$VHcGCgP#MZ(dI70j6?Zx zG=4v!cYuc>0GSNfl;a3xXZ&1i`_Fzct*@8ANyZc47w=mcBk1mCyedkvnbUZaG9Gr# z@jA6DX)DCw<;#YXiu(^H9dU|oZh}IeC#IK_9A?z`^RP5D=?Rn8+G)&i&p`WEE*>LJnr9 z%TB4?X(uTFcZbb)fOSd-d=#J+bZ^1#^CLsb-YQ9AJe|zsM%zx1RJHf!5N?*M zkl9yu-!doO+FJT5#k|t;tj(UKra48H=5PW65-fiDDL(^x#Xzux7kQIsJLP9aR6{bL zkzgFWoS>~E2_}72=USNY(o`>SwHbeQ zm&~(`>P=bzq8f&rLFBg@EI-as1yC#I1Ogl4RsVZOX{hjDq70O-Fn;(BH&a|7>KplX zyHW}J>H_oUEjg52rRy&bH6WkWDr*0%7Upa9vHC+e>Pk`AbKjSb81?pBYZAQbA4(oigmD{D7e24uWNG(- zZf+$x1e_RWnoDE24q6A=qWl(gbabT4(u$q-LW2jSir3qPR{zhoq*(qbU?!{2F90i= zrLS-9W?%>##s)}0UUEJy88Q%ZAaIw8*;pPZ_`&q?S7%-jZp8{MOJtM|oosy2j*P%F zENGz^90LW(gJlJlFV*z)!m@IKDTgImYE>JW@#~Ksk=eZ9i;BckNb`rw4^@Im`i;xE zRaEA%`sE}P;DdwAJf-g^PwXL5)#wJx7o2;C4t=JWZ|A6$gr%3S@FO1gmyb?f)Oj83 zLi<>oG_)ObNn$Je(7>7cu@sg%_NAJ1@E9|ccGT}Ev{;5NBJQ`kHVRmHTIGY^xNjXP zC#B6vrWjwamA5DUMpJ7=lsmyU-&PzrUbDreE58q4Y<)n&ADT^LTMes7{<7D8528QdClY2Q^YORzFa*6u_k zgv(H2oq_~jQzO$6-=9dyRQ?GD)F%G5g=4!cRLQZYR(~iPitRCMiIi2}YE5Cr&}G$F zLTA*9LLL-H3Z=CX6Lx~1x#e_)s0SIyI&NoRCh0nv##~Apm*oZ|2J%!8y0@^8&NU$- zTi3R(X}#*J14euzPoX4#SSIP;Fh8wm6@Bq^!(QV>1Nx@Tz#?Zn)v60Ye7%l@1^Ssk zgNiHx-QD#ix-&&V?Ay_Z&yH;s*1iNNB-lY{uhIB?qqCPF-8#R7ON;u|g=P}>-IrW0c+6#cbot)e% zD&aIx{Q*s_w0>LA+7JFFZ}S9QNhr-ii}BPHGqS$h^J{BDP3Y0@|GM^OC}?OZT3X^X z6j8TE3#}XjDZ0m;TwSdPFP^i(e#TB7djI(eAeanUq?GgXk%!&W))Tn|hktS81 z!1F*&WNWl|y>I17(ca|PSbsK`Nwtfk(j<^IA$9G6gJ}mpH@6wyoe~uO?0Ip<4w}!J zx{tm7rYu#gbDdlCK%A0CK?|Tqt8oI_TRi5rq25t`dm^A(c|odixB|gID*l%7+itK$ zl_dj3Zl%nU6zj~iV`%rhc4z;UR@YlrvQ(n4=mqV?Bmluavc+4*2Y#NL#&C250bQ1+ zygx%&+jTEK15pd0eo)eUcm^PEK@Eu1 z?RZ_WXU+*2qTGxdEhA-g4NhXI+beByS>^^f6AZ94h4?abPp+xQk0euB(-&JI{Y|3} zxH;`S$2Hoa=?JhxHWTqg2Gf}_lxkSiVNeNMYs=Z}FMwn@O~^&-+A7_hVCXx4ujbA` zql~c;W`+3W&so+!va!Jg^fR8+1W(I!c{F<6iwnCh4lN;ogj;J}R5**2 zR6|oUJzhzLnOL-i*gySSBT%8BD)u(IHeNFv$26l<0Gq)3nxZrOKnD!Ibu0+Bl!}I7OasKG#Bku8Bn|Kv`&O%F%5fc8p}z=Ire6 zzqiwsFbw7%UkE8&P17a&{HejcTS+`S!0Yaa9*;WknWpXlIo7{g$M2a)hDv4Y#H6Mj zw1PTe8i%`38Zln3%=St+u5@yKQEqF(?w5#Q*&e9eBY`Zs!p8xqDFlT@^i3>AcQRPn z$xdu1C~t0V!5d)HF0-1}h$IpU%oSI&BFYPQy%4vfHzkfbaW;KU`c_OXgp@`pqr6{zzBH z(c(+40+X7D2Q7T7{1sVySwEbj5msBx(O|Tn!XhsOWhBbUCg_}jH$G0~P`2{P$jeJs zV*xx|g%O($)Jziq`D@!>@(T*~0OvpWl#`<5!os)~KD*l;E`|LP5>Bt~wK9q9K=fQ@rAW{p0J0CqMV<(nhzu3PnW2cS!(b7xK_A zufT|@RV1MvX2$r!ur3WjfW%0&dewor8oBJ!gcQB6sEFO17Vg6?cck@{($|ago6|iB z1HNAP-dY=XgKyl!QtdlYzeEIW(3?*H>7rJplNC}GcbD;B85>1=iW%n$CNHCI41-8p zVwp;NaV6h`w9I3&)Kc)e&{Ft1ZpxPskfs6Fo|eCFk~xhVW2QG*UM-M;(iXSXcJ8$5X5PFJZE&6d319+0_C2Xu8n4(g z$(2=Oe2Ed8O6-EM&j7fabjPIqg!R;Mw;RjeC4`S^ot^AikL=L(|Xqqxu{5+TVOqh_XuPw)VMcom@LNKQ}7ni;OcHspxB}JCp3M& z_E~GnFzEgMozbLJ%fU*`33Rdd3_MKD0k`j?^ zN`6AUU}bF`1%w+DA?F-3a0}Kvt%>pJINB>fsPH-2pd7Jijfb+Ot5zA$x1lU}wT>^3 zKIB-?Td*AsITTwRHu3#QA_Xkl_(IT0Yx7u7Cj$+1l@Qn0tT9f8DpWwxQ?OrV{-UX=pI)eg7xZ7 zV6;B`RJfA0Pt&ymkk_!_0)@`dQF_<24 z2RV?e((9ZZ36UkKaGl<#n@a*88fC&y1;RYR{K^CZB!pkQQn_P$BxS;XNH0rege3q# zbaQ~UxUVr03|&Tb#({9G-6?(8z5-Q|DeBoowO=K|iv@Y=YZTJKQxARPX4n<8<$qfBl$x}m_Ffs&JUA9z&TTC8PqmN$p zZ#4>JE`RAq8k=AGzE&|fdpXu^%Zj-Ee)$#A`dsGfC_0*v9bex3CXuHri4na{>-K9ZN5q_7Vgut&l#C zP-lCxqGHwj_$$CCHUJFaps5wl%7St_JC*A6PcAQy_F|KR$ANUlue!F*W*C;Gp`kS) z&HJskt}{-izO_6f6Yg{EjnDJ-f@*7|u&S&q3jSvhPz*J+w3{BY47WSRwHeYZ@8dLk z)+QR+iU+-}`gL_kfng6YsVx;|C@H8m|IC=ne>vg6s(;^X<)*kUlqtUtFGEn0QPqjwyfxZ$3-^A_0lLbnH8N?0(lUf6Zl>jvyG& zNSzO)HU#YnE6`nSEU(s^WuyB&8rV%;^@((iq;)Hcg*{Lg`?|s} zd`~wEJiPxd1_`?_ezQrH(%LH%ege1X{E-@d#+Xtpt|}iUd2sODmcs?(?g^qnmt^*f z7xJ@d56k0pW>e9SIO+S-$M5}P7;Xn{kS`uQ&(+0iJRCOG?M2;%g5u@>SQ=*#Fu61S$ZHNfbppSJyXO zCN1?Lm+r5~Kj|8pAbbG%BE`n*Vo_}RgSos*2p}OwmVTE4pEd}&I5;=}Hy^uO%j6tT*I%X)K5a#`& zAk6AoGVcQBm*f4Jhq%b^^p#jafGsoE5F}6_>{beEr;^klFhk_!o#RG5A;iEyZ6<-z zi%4pM#p$Hbhq7KEc<2Vfu;qNa`2~E8PGT1OLFwl9#^Cix*Qlue=)qJx{IAUcE|UXw zaXwuAiGE4^g%(O0>TkUN)SdEF@1Ak=QemKgU*edrWalRY9F>5W>SS#!yw2E-gNwV? zjz^lOMrHDfZx|zzV4Fj3qHnhv$h|{#0as#?dL_0`v zVWrtBeO+8~dneX)8@(kOekb}*S1re{nL;Br1i}eHdgC@<#8e^DDiM?~E_L-cXTqn=!zEO}ryVJM2c_ z3MA}FhoK4dR?F(-ol%D5^*bSUGWcG5zW z0|G=qa+KZqydU_hg1;M3d=35CdDRJo>n-(%rOJeIV>iCUMaK^N>If(2dT>-AaXr| z;Nv_Oa0XLz?}zJgWwEFKU(TQfo;_F(BOyRF25zJw#6mWytF#MC+CIf9aKs)4rN1JF zIXmZHL^_CtF3Y2^>}a44#NfDN)rZXB6$S3v7#Pfe5vyp#Dm4&P@dHvNI?duBD~KG^ z63trj-URS3wW!v>ur`9LCBwg7~l8G0|{Nf!lGJ3 zv4~@&u+EtQgK2^!CCt#`{J3DL$7`Ok>4r=LMJi3OuI2*MzgO3@tWt_0TY90iz=JWf z6c~M+@Pds^LtE=)ey`4F=Y$k^-}<(s9#OOXKK}4A3teW;8{!3xNUC{wUWUU6XzYTS zKnMg|A{|jeL%^XFP1qVce-`vjGLF82Daf_19kIAVKH~PLGO*NrVAiy1SFw`DAoVu)$CJJ3OqQ^@k$a_&+(lIDKADoqy|gScm@7}wch8hi>+y| zX+z{1v12Uj>rx%QUgMGpiRfDxB05;Ly&F0TlrIk$i4r_ddVs?T&A7#vQboR>owx&3CP= zU2zm-pl)0*vejuP{GJKxnwbsn-CC?@e?1|stgO`0%&7eO-U|w^yRkb`}m%_jPY5%i;VmE3j;a9}Y%*8?5_V)z+4fZ1QAJ5bu-yo!p|Lxxm6zwKk3c;B_bpVuA)35%?0|TnN1^G{7znubc`kzS2klD^d zs}FLKKNE4tc`P=)wM7PBayo#z!*#I*%wx9qI{)QNv27&T`WVOE+=_+mGR*{sIPGm) zo>mSwxA3q~B@tpcI=U-O2|et3boE_>+NR4h@`71CK|zB=v9z))rTBJnYp%-$|JXJ^ zAfHO~_hf9A%Gh<<4=_fxiFf{xZOg0|vAs`HS z<3?HouU((0NTNeQMwTb>4*IvdRhit)hjGAMcKfxo1;ioW#=hZx0Zi`!o#kH&Ohk6| zU-6gE^WMGt_Q?$e$!sRCsHp7gXCQ3T+pqrke8z|JITc2h{M7$gi}%_`LL)#{%r3AN z%ZPZ7fEYGjRRc1&SB;#;Eq&>nuk(&iPrl@(NqQ7HbT&8y^quJ-?VF zJAHNvMQC4;RlO~io578WKw=ihvHLti9_8xBwLVjKeCIRDD-P*F(B4oI?NCQ_p zW)|En;J^>{IkVa3m{Y!bWhy@&OF%9*E^}LjwanabX+xIfIgQ&hP34J&KAmqQq4pu* zWzWE38B4G*z1|BOwYj>Z8pZ+ND?@uqygmb7bd0UrTkwQ_KMmE;EN|#4stJuWG!Kex z+PWF26yP*(d1GpZoN{=4lg0=LtCAwYwZ{N(q-4B*VeRK zW+Jmzp{UkM5T{9JoUd?_TMj@s56VYVO9p2GEbQ3Q#2eBiK7L3~cdFEn1{*|8U2XZt zh9bI{8o5Y^qVW7va_+aaAIn?1@DP`LoY+&mM{dt7W^_Q1Un`DTdw*AFN8nikg0d?# zuRWitagH;b!1Lsa51yP%uh2jLX-`)7*fginqm-s*;RZ;~I&!lUXfeRdpcJVs4(;!L zQLh&5S7} zHB;7b8BDyqynOrRo4xh*S-3iXRvMX{m5RJP36uA}R8{jA4@gPT{XyxilfoR$J3&d}W=30f2-f_Tw{1S-S4)-}bvg(6d zI84EyLnieYifOKijnFyifv@5mMmuo>J?DJpv!7E%QVJ~x(tAUw^j< zy{4x36xnpy!9PGmQo zG;cH@GX*3m?zK5)-)@C*+jRCAP{)=4O6^$(SE_7;`jR$C ziAKk#S*baUNPTDugIssAg37zX=7PF0ui2oq`FYGBMSIV8Z8@WBQ?qDv_tKFsY0 zKN!;loe?T2$IZ3dy;%6{QB~gbY{oBWWA(5;;LyA%bPY4VAV2rBC1HzMVtbaz7fB(- zr=_ZXlLRE1%DQyYVhJXVmSjn-h1XEBU+&jlWJ*bboi`u=93(YAiY=emGK0-{1H*&PP_e$z>tmDo!B z7X`vX`qnV$*Xux*v)=OQhH2nH-(^@(jjnA2KUtG!SaCWR>g3u0Q&aF}qvc=7$U8{y z${$(R8QIK4Q|d1i;O`$X=a=81j!4fG`4N>Cc zM(sx4&E55R+)0FQeSP2#xi~0gF_8~be=%T7h49BfriEh4=&CZMqjbIAYxlS~{({-= z&hX={UJV6v(bIewQT$t813Hw^bB-x>=p+!n?3FoF9lw7ksh?(^C`*TdiV_L>=D%OJ z%y;vt*h#VY(+ub+Q!|GDfHaaeY;pl1v4k>bqXtoD1#E-21sOUqq&ycRsOi)izlSZ zr*=^>mVqlssggHrd($8PY)RicQSG@bpO`jWr8-bxFrdyS?5#5i%&D;T%ZhMmb$LZa zT>V@=?k~spaoeW?1)OlzRmf6?gpASheIO`g~gJA+yb#62E+Z4MO; z?~6(Htn>LoD>^y~ZvVFBpi7Y{#NohF*;Dh8GrgblP z4Tom3CNRxl{pQ^{lo;;+Lq9J*f4zfFYderQHL=ut%&wuy@41SESQ6EG1T$O_ku(*D z7fWFR#Bzg)oqr?*aFcanFqRSINCIRIU?P3SZPXu$Tz9g~h~IRWg^Yujdb08iaXqIU zuBLaXiH#dc{xd3TFNiJw3`O`&1m*G~$HVzs)hd9DEcw<5b-5aHh)Cdh7>QV2SiS+7 zC-v*_!r7G97{~_0Z!xV13^Es|9MOyw7@6%NOapz8c17{*hXCnUjxe2v%u_P;ozto~ zH_{FvE>@)zAxeo877V7-=te*vxmCI+o~JVPrKu^y&7_4+LB+}$OLLOf29v*yT6QI4 zaI@OOu_qZ4jy#Gu4^yaK3Dy&lE#Va^RK|?d`R)a=&L<2)L!X7ew$BxXD>oQrddUMQ zOtaQWSn9XS20eCaM4BRTqs^RS=<I0IGQD&+<{6`nyhG{U zNp0yQLyqGC?eKJT+Ti$nR~9w*VUg#w6Ww1DX#)(t_Hw{lhv}oUpPDZPFsnU|h5O=?FK~yU#f=zC7O=-~kW5EqV~}33bd&+quyun9gb*E?g;kav zixKrsg9f@GNrO76dbJzG{i0!|*gCM>JqYuV|V*n2bP1Es;x9q66uX zkO(b}S%46$!sWshLmrM}*2jw*yg5_~NNVGQ@?g95e1TiBP&UixhxO7O>X2Epk-xHU zAsxw;oIgg)VaC8_|EBZy4#58BNof^{4qO~aY!AKPkrq&Wyguz&^8#5)%<}XkuCw)N zOJb5>#-BnPo_w6(#Zpz}N&Pxf9XX~;n*hV9pk%L+fJrWsR{{E7&t0k*!A(YJr2=O` z^qjj;huTS3SYw(^Qhp7`H51Vh%mN<7wRyan5AT=QrBS%FCY!69cFK3eaoeas=!z0| zq5bIJEwQV4*@rXjhfF=GQJ(O>*jGYAOq|GOlb)s)WYIqeN-=ypVM^W|vieY>gc!(6 z+zfoFD+2i(?vuy6CEBAS##9+LqmFRoj|b0jOhr@ILzrwZ0YQZoy~~1qrE^j=foOae znV#30?4@lG6Z?i;5;Jb3ZEs-Fi~GiMYlHvKD0KRyXOct}XPd6-zdx%gua0daFRw?< znYMQFO%aXT6d;X)?l^$oxJ2n#2`WSa{r>59BF1wt(A&Hh(b|L_(vTG3US zrooa_whJ@}d}4fBnuP`vWL7E^Y75l~1FBTds2tr~810QGL=0vyNOyX7+TbL##7N7R zjxH`$pFigqf=z@^m9~w9aD{c+r&_~_@wo)UmXgHwBD*iYKQ-^qm{jh)E(MML?z4h1 z!Q?~9W5HDE2Nc7)lw&~cbh%q}2v6v%+>C&;MUYCbRkM^p4ZI4vQz5rMVd)JDNXw^e zq}ZHB?QfQ^zdk+#HnB(KQK?&;7~Y5hJ@2+xQQr`Lu9PU6`Y_mhMIz??uud7}+jKWT z8KFm7y$vi%ErS7xXM-D{SLE{OX!QMYRfeSOwS#S3hQ2;%4?{;;38DbBe)rifczKi_ z=LEoAq&qYF9|qu*LqO>2CM|7vu2@sYPVSTh48)^hPNFUEto*27gIhqHl~f0JkU?5VQ#{Llr?CPD>@yNFszf6mAiZ+`4mfD$ zRpn3RWG6b7WQXXFAO@P zPh2@b;@OQtEmdo0L7e>pruZ9Pi<^mJ@9h=B&9e*7<=>Z$_P>LHiV{q3X`$N{a!pZW z(20n#Ic8K;LbOIlLW~baZ?Y>{^ae;kj9g=qqf-9G^h z2K;S~)pZWecj84h8EOu?KkA9zm|08=>gC~d`UKbe7LL2vn0^V2yopmn<1zc;XGX?l z`cGCh?pOGtyd2nw)GDy|=bMt$0dqx5i(g7O4!+l#7M}`ZyBgp8qM@ECi8VLS2JwuH zS|{T0Jel)2G7@Uofo-YA!>L0y?CvRD$K^yjn(g?;{3kxn zZrgzgyP;y~)UBeR{6oomoQR{Zk1+rveY*U(62a$S&I5lt5LxL&ktj!j_Q+JD5BDs{nR@p!Wguuso~T>*Lv6XA7aiXZbW^+U+dGAjXu zs(Tz#bzW%83?bj9)>~RNkl{* zLQc%&Nahz7=Dq}B19D;@oFrPWT+XFpK`fd``qU@jc}^fh1>GUt7H<{Mw2l>&a>me=9{C;c)pJr_q;qQ06@L zTHIgf1fAS!^YI2Ia4odx8!pqm_}QMa)h?Qnbc~0o(YC&&0PFaJKufbIfe)&2TgAhG ztF&>q7I1-GQ)7so7zWKJ*bJiyiR=!8yN@|+|Ua?RA6KHQG`jGYvl8gj(Zak(F- zGd4FTE3c28K|F&Q1!Cq^`_@Tc;CAyiXsAy_l{7x(Ax&h;pj=B}@*0$b{`uhOW`?}b z;=cZ?CgY3OzNp3Ryy0wP&2bQ53bh(QY)U?0(fY5UFm{&%xnLzMi*n78 zV0|p^c6Q_3`XS>zd_!7t%4n^QTe3X*!uvH&tFas=^ zU-2VVRA_NaCHb7;}cWFy5Zx&SJsT-(; z@rQDY4x8mGG7v>1cz~8HsPNs-40Kp9Zi%97QiPZ5ulQF~+C6_vTj5qlWFMb5FSmAB{X`7VFq8MXWh;yp!^a%DFhK5|tbt zy*txBjl>Vjt=v@dh0>GI#1-95KR+Kx=9)vh^>f_X>NOaUP9*Go#4{mIrbRCwny;WfXwG>b?#>FX* zkz|2EYW}N*yjFkEaaPk`b!oJcC^E;pzLHavP2R4z<5_^u`53i35^jxN_^jRqt!4M7 zF)BCUWPovi-W(M*VtuhKylA1bpk{|%*kiuu!w5H(Nxq|-(|3Lxuzzdi_eTBATQU36 zt`9m9PO3=uhG^iusXCpJXoOV2vLAUq+-8Bh#(>HU+Qu&q0{H063Y+@veJ}_OHl;nt z=z=7wVZb|{$zUPSg{-LSX$BZ{s(+m4yk{hBy}{0KVcB|Ssk3^3qWIxgm2sQBMTkTEB4DNylppBX^i6o26sVx+RxURCqeTLe#dh>cN|*Bl+c7mcfs&9ri*A>yOMhH2O@$wHU51E048{KrZ(HH=FDG?$*h$qz;qq(%`1e%K z*pZ7gNkdZ`AgF@-xwE$So$Y_m3z<@O{M?yz0HTwx10cbHut@na_9^%zX6u8R-sjIu zueS?>!`-!~#P?Eh#uqZ$%}okKh*T+iD%fQ@WQnc|*#?#t{GuSu?`D=1Of2R+5zk4~ znQulfPN(X^VjYTu(4=v8q(jIi`Hh=`g(Q7~=|}?M(Uok~{S@o-cwJj6>X|BUv?qP} z=Q!sy&=j+#U%GK|F{Kauyv8#i(k4vc&GJCz@G1GjP`}qk@vZ-lEC^YrG!Oq{2cj*C zZ+b>g2DBd;z#LIBg6d^MB4)B}_0=NJDw{MLb1G!C>RDH=fO$=LhQtO%H6_%^xC zd$tN93R!6$xR--A2*G(s+S!4;0CMb>QbLkgTX7$CuXiV|8Z`!G@UCp2Ch$JrC7qWL zw+&!p17ogE$4cJd?(Z26%(&1&N@1PCvc%1NelRY53o!2oZ- zgWM|#`_&G-iuBB8{2v5_OX5$V2C971x)hXD8)Lxy_*Wvj5*E5v`g+!DRB}5G%mQQr z@tyzxy76&DB;&pXQ2Ag^@rni?2|aA5KD=FL)oya0;*h#3#pkcBHA(bQkP}HUW59S% zmq4^MO9AZ>DAU?rC@p&*lyTfy#zu0Ycylu{A>e@5iA|QKQJGgnU3F+G9i78nN`>a< z=hw6DWoqbtgu;KU4^5_P{7Wd;h}68@7E90ySJ!uuko?`G3;k#6M|&ODDlV*axM=>W zpa85v`|8Z>yse|afB<}A-j}~G>pibIfaMVwYa$;68g)uJPJ{%_f&)eZzvjaUwOO28 z-7AC*k>zwU2E7sB+70ksZR1{_VQme*CPJjrZY2{Vc8aEAEB9gq(no2To^nO_=Y!l1 zXnT*hfegam46@9arP6SbqM6%1VEFZcv?$D<9E(6ebJ}AuhNh@R#{_54M1Z7pbpgt%FW{X9_ z!fI-_|Mw<xnz^7J;)HGCw$hY5Oip>0 za(bN{)zdbf&`8_>*Nw}F$IHOGab=2j!EYdWLS8d0TEnsIcD{nB6r+9(bFRV5l~W%! zY=P+yFJo|{D_*IUQUp7lgGGkEz1Q%F@8%t(-mD&fS~ke%j}FKFml5yUackbP93pLQFm)lxQx*gR#!&|h;5cH>R->p?l+R>yNtEj{ z0_&~Dbc(phty>MUq})nO1_j*MW-1*LkUy9?>T@tpaceO<7}@=LuHA~U_->;LBr?d` zv1sX%)N=+R+-6g`6)3Db;0C_UoTdoCK$!b~G@W-m)&KkdONvBfmYLbXvA2v6viDxu zn`G}5S&^MR4OH$=;ja^ZohWe*ITBay!TCJfGL~xE|O2;i3&14(z+D zxVs1*kUr|arR}j;pD5(IuKqC-M|v*$$5SV#->F25Yejz!9g$oG3bK$V_aeP0k*;1l zOZVsJ4gUVkMjZdb1g}Xb;2IMI83P$6vM+(yk<4V!n@4vEYzG7Pzqn_$aVL>sVhd6@>W z>V$jS-aRoC5q|@bEMh8pkuywGD$IzI<$``HoeDG!nwTiFsBw35A6q^Fc=tXs6RYWA z{~u_EhjmZFFjV~S9#ea7yQpd%!U!eR3I%8c2;nrC$(U}BhO_RPm<4|Hb@NJMLQNX8 z-Hg}*uf^|z259^f)(xqY@RZyafiPrwG`j^Q~yjTO7J*66Ar`(gT{plImFW z?bux;GA`?n^X+A&Zkr7k&CR&%cSoC-DT;(F-IPp{B$WyDvUgV>&5Zq)QC?@y=< z=9+Gd!?8HH1wTAf{hQVrq)QjPF-yWy4iY#F8#0r(_?KEHb~@s^UL_BGK;Gbguul4( zVy^ofvu`N9AoOWF){Z>Q;prHAo~8jC1NSeT zI^VS0oYrH%&U_269x`PnB1@v95B(btXie*w^!k#CKFa^G2YwKc?~y*Qk1HjM$&+2o zy_cW+@jn zs!AfKvAg#gj=t&3Im&VljFwhN`Ea)2IW_f~W-QeXuJ#pU@m4n{((}?`n5Dmz$%G+M0NabH58!hKsEjHPD&0-Z{35Ge`(Lq!T``9Q-U=(2)2U?Sc= z*AbV@K@QEA`FxPlO#61X1G+fz)91+kf#$P{R^1v0q3jK{!Hu=+220wIdq|g;#NS(( zt$%AhR08@9Po}U-jM11ld{srX4@6pRIyi4wi{EkuT<8RR>4WPKcu@~otTaUGX1He}*OMSsU=fDQ6J!U7Dc;DPlfab2wl3XbH z{cHEL(h41xb_s%98Oe7qwY)=X2sf3mF*?nT)U!1b`MIe(#6i|oFWnXCm}@Wv1@iEB z;Z}=Hsma06Ckodf%$*l+l(mA)bHN$}kWLA{?PI-otL%<9n#12a^06#Fc{Z<(5|Ht%W zy}Lup>QgW)`N`>qfeJ)sw41Ko**s@W(yX=M{+S>41Zch*)|X8poI$4PZfpa zTK7d$n7(AORC43TQ#(7m!RbHyBAd3%7!q{ZxxUKy6$Ewlb@v2>L-3T8ei(RSf$15@ z`I&g_$qt?mn-=XfXGaG+Q}}xM;jC~#2t1WNzG7%X)nqJ1DWjyU{J+ki&1FR}Q6mwo zj84wX_ZQ(&$n~xmQd7b1etQEjyv^3%KM!cG3F_VP+OGexwjB?bLDFTGTHHJkW+(sn zepfq*I%d`W`LWO%5oKrV%`ZU6H|3rMJgZ>J3hd6GFET3q!uafGYTVXX5+Z-KwuG|; zxaHZCm*#VFaY=9|Go-!yD&K!`%;BH?Fgo?%SOaanwiN=pm5Uqt*c?~N&JY*R+MvmQ)F z5W2EbgJIZQr!#)BN{*SsHVYXRdyU1i>-?Yyc9P)NB4I?Ycfme_mvzxj(p*n z8DzEJiJf+(!9bpl$$I7OA%~#H%JWqXB10;Qf^t|`f4EHg{Jg4WvSglWURKJ30@LT* zbGWc2IRZ=w&uxG!toFya-fc6qc<-u1^GVh++RIgdOe?vYNwowA{bR(l_U$!d?8Jj2 zEO*<4wA=)F(&*;Y{kMY$iLW^$&duHJ+Ui-5tE!{ZGhc6SYrFU69?;h?C&Hzs+{|2_ zEO34hO$DAd;C{*k1D&JR>{mHCRu_|ue#gZDQOWjuU1uWdLk!`0cdEuQ;_Rxb*#0zH z$ZFBJdxE|znCOdL&*$VX)zW-BYi_jHLZ&-TWJAnAv@)sdvS-4s%uU^XY&uEUc;}eTnBIHe`|TWlNyy z{i2_~fx(25T)jJ$EQ>>fXVr4-mysNS91FTgY*>CF%{dsHxGlUNsv!YFGq?zkUUN@5AJ>l1lqrV73Gz z_Df<_$*{%d_7Rh+h*&+Nriz~9KNev#cTTx&LhLBzPo@zYEg%L@B-!k!;dL{wS0u=% zOyjtj%Q-~dop^$d(FbI!MbS87#_N9+&H_|Dk+H;w9lDvmyMg%8sZjIf5O0x#UmBD? zH|~$X(q`|0In=oATeGMrxc{VqjmWldUqpcL*`f0Yr!28ale?i;as7qbAsLPYL3N}g zEnQwEMTiKGiAtKOfx6hOwa>T3-w!kOersCwHh%m8Q9v&AD-uit#i-sAFG7J0qb zOcrEvH*K;^PjdrFOV|IQi~G%mTSn}yU2=$lG)W^H2u^TykdOVGKXlK!mAzui<-A_% zdR5>qxSgXdh#({jwP*43`r)5{K$#0@I$CcbJUH8W=;mt^r1|iqLz=s;RSysAJ2UxUg8sL<&Xb< z*>-al=2gc7ArPeb0$ykHvnYOz^dh#!W+E7Ey^X)P$a{Ww#Y;vNg(*NVk7_WqrB314$_N^&U3=M)xhifDJ0;< zEI5zz6=My=8$Cj~ENUI#JadGe3~E1=ULGE|y!`_Y4A)>eJj%HwhNqMRp8xe54=gC_ z{Ze-8%;<-13tgOusITwlgnM0$K-#FxTLYbl*s;HYPy9Mp9K^6|Qgv0F*X`_)&G7saCme z0Ns-JWG6Ri^y<|l{tPH0iWuH}F`I@3D{Kd>U-{iopqCU)XtKA|bWFy6H@nU?Sh9+` zZUFy=#B*&Nh_Ux09^q4`SiH6Te~7w+L-!6!-{Gh#)1+erG-woB74hz-g%Tbl@T$nN zbSGxkt+sw>q&|tcYwc5uh?r-nnyXZvhgBwY%0v34?QqAQ%k`kCa<Uq=KT z208iG1o1=k5tmz*F5RgUHIvr$x7_*r<@r%8ix_F=%(_M4`L>W!;M7%PA(?A2fAu64 z3ft?YFcbj;K>t1F?29S!pD}&9H5QLOolwg5vRL7ka+V@m5Bgf;gE|(r7Jl*lz&!ux zE+Efs{mA5*R$2WE*MB^rCmAiwYPs3A?Od*-e|Bt|*DQEqFx)Oq-~q+XjW51kh*|km zUUsOs8oWk0?%0&dGZ}>Dm;Na(+Lyi;#nMjC_vNPonfJw7s-V|jf5WQEkjBk?n4 zQV!#h5EvX3)cqb&ATXNc#Q+=0xLb063RBU*fO8pO%@Diw^m-U2b;$}SUXEp2p?4P) zH;OO1d}&@L%MDqueU;N(@{Zr1Y;E}}aKrMc3m=2hU>@tCX+*v~gE<#irv>>|;^{n7 zc*IK73TY0cV=i>4l$zWmJ?3GX^zg0Ozu|g9yKf0p-6%n@x)GG`M77{U2wnpUH5+6=^RpKi({AUI>HdKPEb{g(9^cO)zKiPl%01*WQgZnM3cH~h@KrB6U80=)j)5I3?*(a z)PDBoXzvPH^oC}32Jvm}<$5kk;%bmOkJH9H7vUjl7_JX^G~ICB$Xy4C$IbUXs9FCx zVm3Td@o!|KvaRzF?QFJ_CZ4;@Y)HqvmnlBD4JWH=B%kJl2rFX}f| z(At=~DUP(yliEiWCT2}>o?kg zL;#gQ0cMEu_Vz?{L5o7Q-T`Oq%GsL*oLSaL*D*8c?2xRiEMQnC7@K(maqPwrkGK|J zvu7R*GALph((Ak@+5A+`n>6`73r6sg%)_%Cme$690pXGai)KBBi|>=jPK%-hG~Yt3 zE@fEaze*7xu5(Keld=Q#i@Ta%H z0yVOirQp0r$?v>4a;Rnh-T8Z5FGm-*q9!qvN9OyB zu%EUc622Nc<|?a=21O%4gfpi^edGm+PlXA4+gleZU8P}St^eN(p!m z(=Zz|Ch8h#MGmmZhly0M5a~~IK5LrXW!zW$Wh3Jq9;BUCy3xwsVmi!Mrp_jei}73a zed?bgku+tUmWn&Vriwik7>gqhrY|`6OAW^?Q zOE58N{T3T{&jJaRdsx6f6JQtRMJFdh{VJx7S8AEw@1c}N+G}TaN2(n2tx;d0{eP_6 zsM?GkEc_20ojJE4Lep~@qjuwXd~!xc%82UZ1ka*IZ$y`p5tm*<`2I3prGeHI%Z5U8 zt*)|2umA~E8shJN^A1xnV`AqArC4kmV-;pg&=~_e+6tgydf_f(eJhm^ zF;)@_R0k^f|9ZwZYFdi$Qq>pmReICsAypG3!M1N>{+;CY#jK&D7Q3#0jXT?DsXk1MG8i0vi$S-giYH=`0HaaH}<|EbGGW@C#(({ zM$f#u?r&;yY*<_SMVNJp);~0>tQk_*uCzWy5kHh}S2I1ej(9WpR?~_1E#$)k+sOQ~ z(n2+692V{+)|OZtnELM6cKu*cGe-us1 zzI1!F*fW`2_SeSoyJj(rDc)}kAg?$)FL?33o(kw+pBB(Pq67LRu~G3ij{VE!0$dYn ztE~n{U~V#HBqTlp0#YPY-vaAkAtb-_yBe(|Q!@F1MU-VUX`*t`_e%ShZ+||)On1^I z96ndVIb2h2zrB+ngoaX6A<2eRhpf_rV-?GoVKOc1{clsFL>KO z-iO6h`E?%p7u>-eJ_SBbN>s}IxR@fa;KC~NE`m_f$moF)RhD6!TiS!qPis9^t+=ZN z(=no$p1j2fEB$=4^H58zN|A_FxVOBeg(C15ui}x_dT4k>(YMa`_rZ0%)^YZGV9~l` ztiq^O(Df46`tnN9?+xB1=*gp$SG@#sV{$&#qQ# zGjV@U(&@%HjI{3So#XU;eTiGO!Xe z6adg_0^CZE)0%&wwq>r)oz-BsEphaeRB`I9fTG*YBZGIOC?`XrX_P8wWfaZRY5Ls% z1j4+RiTxB*&wG-n5=XtF=KEy;jzFSB_x*?WL1dod1HqwSOS)g~x~mxQwn$i0z^bPe z`M<5I6?Iicg8Q-M+AZ94gqLZ0rlgX&_T(7M(c+0>6ybSoY&Ga{z8y9*!p2Ye1Tra5 z7V_`$H`0A)TrtA6k{%{f!7o&DS=DI;aHWI-H@vyWQ;AfyevacMln{rTy7*s{OFba- z+FT?1Z*y!F+5bjMukAgxfq>H=wBM}`NGzg@fA#tDsX@-RPA-`!6k`AD)>J~X)V zNLme?J^8D-cETE~tH7s64(I(|S(#eeJK^8UmXv(g452X)Xn8^l`~me_GqpYl{hDTS zkuj+VU_TA>HFrt#i#NZRwA)uWesg2^+)cVQE zD>6`2)R2PjcTDT?+f^K_(jEP-9owH>jdR`Ke|D*yv%V7cKQmJO$;rshCaks~6j=S- z5SxrTiBeO%4g)`r{6)szzNM21-XO%L)hZ7Q+LxgnI`hY!idt`kD`r*ErF)ib^}aR| zcVe%zOON7~Qqsm$|EZ(K@I+Psmw1yol%Ph02nPUTfwVXIR^)qdRZ`A0$Vu4occDi2UD$U6D^auN5Q4L0ev zGih@X{co-Wo{QX40m7U#vqv3!rhkPI2&JZgHx(7xGY$N^zXQk$=;@Q>!4{tI(9fRF z7n3G_kq*LNHn2bxV|#g4MeNgg)aw#wCz&ZFJ3D(o{6)H`@+GT&0ugv`m-1L}vau~0 zh2+)ww34SSrQ^FH@^jWoCD_fsaf0)gWZfYDb9h$R>lQ_l%N=6H-%H3dP*hPdPa_S_ zBdT2ik+6zA@6CkAejPKcnw#SqiwuN4A!`~HX6P9u{*9e=}XXpRD z@9cl3nuh!%Lnbw$2`~o}n#lnCvNijy=z=spfn|{jG|a1mPBB$bz~at8*Knkg=5L^r%wp-jKzb-50e5&LR1^FZweEl!%$%Gi?+yhM_0% zxUD*LE=gV*7zrJB$}MX7?wozks2Dc=sn2h&e9b$lUKJy3`QKN!c3~)BJP9IXeynJn zK=@8SSaW~Vu#~m9M&+=1yX;7AgH>n2M8^`DT;AfErI7NLD}wH^)z`tpzMzy!TBc}a$pJ1#w>NnN#wwsFQSlix_SmaBHYT1b@B>4lS0EZl3yF~1k zn`eB{g%(m-TrvGDz9V)N{((zp7|~VOh92dXsGNC`;uz1wT&|s{T`QNu0IjH~YH3sS zHx2H)#1NK?O!x+&kxcA;mQn*;23Ax3O1MvttF4jj4NmBvv*BNo?EE$D`D%FkU5%hm zA-Y~@?$Mtlpo4UtmJwfxe0+Gh-k*V|xOc&&-SMNyT7i@PCK-xS5AgKqUH0ZOD9Emr1z%Pxnt~>1= zYWF61w4zeen@wZw@DhDSu9RZ6piRO99ifbaPqW}iCloTcynWsfnXa@_<#;)5z}C%a z;qLzB;zBRwpF7xTYUbw~>i*p}_xPV6C`4*};iTY4KPRU$^&5El--yVAM(~Y_iMR`~ zI|`$V_=UA?)LwIC24SGNTor*p!aYsw0}Y=W;tr?+Gs%PN5QSE%{K0oqZ4BD>EYdXP zdoLOGvqJ8obUR%{ljXx8 z4r=T=`=Kw$rXPsym!?=8SU}9 zu(&lBQrl?{2{ea^7$NWafpOfj3DC~l-kSG_?I7x!>2&oll-gDyf zuH~!Q_A`%;p#0{R;orZZD&hx%ud)NPH%pkU*0+BAs5l&M2Iki5Cl>k|bSk{T>W*@jFElUfAdeT2z|bT8p^hNxAKiwJiwCN z%_?NhqfE)adh~dNK_hVr%05zCr&>JWP&H#{?p`ieHch9X4t??n3#-}jjNLAo#s9(0 zcIVN{&-gS}3xn8e@(+{p4NF$YaCj+{C@0YGJ5Si)uLUDz|575 z=xkK(T=*g^n!e+a!K;MrcNe~yn9hmAoH}e(oL4hg*UfAI&atn#gH_KdUzl#4dr<2d z6wEnHK9x#$Q7o7<^D#@fD6#)VMymUL%=OQ?ntnOIZTh4`y$yeQubRd1Q4MaVYOW?% z;xnTG#<*Z~QpOp6xar`qe(20Ri=JILxp##^vo>I)i;NX7We|~yV}I8yby%#5|6RWr$gPu423o<^RU0?-1+fcQo@mqt;GIwdK#K(|7y_FHI#a{u1jSZyM zBm->DVZx~~a_W;{lx>5)RklO|f%LN-kLYCWXhB@s*lLFiGg$ZjASX(|*>oe;h2L?Z zfA{7Jk_t}>xraV;F-)C^fA-Fd$7NPcFjgUff!GfVjzRG*A;P09Oqs_mg;3fGPuZHi z=gXYY7Tcv!-&Nv&k44~DQLID+b<3g{7cpb@DbPZ8J^&*}!9j6_F*g zd>>uK>N;ani!Yr$3V@^vk~S$ojPKadfge7ag8=is)C0cKdh!P#CE;n@v!q4g{lAnR z3&@kJrt^!X^wFdB7Gr^~=3B##PVO9m;hH3mGE3uBzwR=}HC6#=ZOW@ib4ny^!O0xO z?|e2lJo#(8V+5^$b4YEG@vDIrUA`fxd?uR8@K{(5JERL55=Tc^?qWzb&>%O78McYC z<1@gN$a`%AuleB=$2Gpg^Atr3Q6eB7s)-SdJvj2u(@Rfakn==HRqOKlUK~bq2K@B9 zsXGD+j#X-9{#EwwcFm6BVcpTg(=6t?ij4_F10L}yZ#kc`xkAJ8gkG1%Pzl ztw|lV0YyB|OI@oOln8%N%&1=TYG%8iip0Tuvdn%C)Dk0PqUBY)>Y-*?%eth)A4j$d zb9t!r+X9&_Pv_=iL*WM2eMV!79Vdf4-rvwXmT2>;N-|E87dG#ve0BBo%{=Tv(n{n= zx1ymH4dCzja}FOIKPDWJad7kSNY&20FRzxVBOsKfbxBXK6z+U?I1@T$d}ebr)S_oq zDn7#N5oVc@JL6(RIZ$L+`d`YmN8Fx;g+;{2i2+t(Nb>M8J|0(%lW5Nt|F}+BI+{)3 zALW2(qwhB6hf4ee0U87TSl1i$qSr{mdyQ)b!XO;l0H#F;uv2^X#% z#(+na5!S#iE(dqPe(fm4n>giRw)+vLv6~Ed%<2T5+Fo9XIaglb3y6~Kojqt?6)e0M z(ue66XtLL|wMhC`D-(wo{Sn6Z^Fs$3yci$dvT2v7EH;69)NaK(UjqDY_sO;2WvO)Q zbpC{mDoZjzQ6}S)N9K*GwDwHO#{{-HjuG_h_$Jmu2}+F#EWXz=6jr%wpT_dHD?a z`fz2sqF1kM`N)Ywb6c~qS?}hmp-1EqXYCnid+|;G;>8tudIdt&_5AmDOD`WtNo~&s zV!0&L)Xn!EiTI&m(+;jDD`g`}Dnv5R%2?rG>4H;~N5S7EzTPU@qxR?UN;idAg5Z>m zrod9`ts|t4-&YwFEdZb>-xu@|)}7)`@q(J12}0`PANMn!s~@ZkX)>>0Ng+l)L32L8 zH{h@6+d{Ux?bX%3U9XQ@?pN`@8t^-~WxD^JV8v+Yc-peiRxIfAmXudg2Q3D|nTMIH zOKrA6Xja=^YlP0B>@{8Bhbo$+Fq8eNWa;OOkm(nfAC5>2;p*NhHpMZGwV`!9W@2!7 zljb7o=oa#&T`Nf)ZUwg?Y5 z6S5SuY7{@%a$idy>2LTRcUee5QTgg+?mX!oCNE{RL$wau>zVv73(lS8(ZL{T9J#2whK9rX`1e4 zCEgc7|M)U=RisqJ%QOT(zLpF&D^bk+Cf3X=H!?czCz!fN60zE3@RVAbRxUvuJL>r4 zY@-ZveDZ|X@NVuV(msCiljB?=1Exg$ru~s&#awX5+fwh(0ztZ20pQ`At*<#@q|ngLN|6sO)ik{9af^6yyh-;*bT6>}044XB0N zvBoQXx0=i>qIO=6#&S*jqGO#5(SnMNQAfQ-~EPsDF;67XnQu6 z&!j_@4*YV|o6Tze>4iI@>eBJZ?d|_EFg$!l zDs16x+p$uq1`H7J29wmOWExaVW~$P62uF~&OmIv_BcvB9z8qK=;Xh6 zhyic-VEDPdo)4_>0&wup<@gNJ-=2YD=o!(+2Q!mSkAAgnRG3%{aS+epID8)6)#tnt zD{pf)GWWTh;=Nzq8tQAz>K)Cr4(;q54I5|3>E97*u%(emV+rG>kK)lRLO3ZOMId(M z17vz%D`2S7_O_~f4k{SOmeoJLg~ETVRcUSv@0^TnWiNTu(gtzA>TF2fvu#?&oUTFq zOV0Rw38`sIs!W9aOM+MqE571|B{RLfk$WxEhbrdlRePIR*pwm#GhE5;IXf6MkK^Lv z=_}hXw({E;b!y;LO4#j-$O#|Td0|uDDw?Zrubq-&!)GuXs|3?$bZ7(+DW*tzA0OY% z&7FeDDFw=gW|0GyCr^%S%9)c{L02;=!1=Cq`V&LmBvO{}m7;O8WbNGGS+pcAWC9>a zy9Oa@vsNV?Z_>FyJML_Df8%oG2=!fe zivZU??o<4!DWq(PzNNeO3siN<>1lOC+Xz?+x2?~}MGU#r>lYMPl8Hmo6(K<(C6Q&& z>8<~oKSg`1VkYpvf}_L_Ez2COZ$eWt!?42-Q;*F3Tg52=-yXr0Bjgcoi4D%9{d+vL zsCs+l(dQl1p_{WYJZ(t}kwmatrz)r$M2{1Z|YX|q?o7Y-TvTW;9)WP;{ zx#HJSX!4m%hVe%QW?sEpPrMY%8KL@gXD{(#57mXz%(g=;4W$VO@W_DmvuejDV=m)1 z4zQtwLIeNhS^nT1BI0YOz{XK^Rqb0Z25gc&%Kv>j+@k(Uib|y~ihyPCJ1NFl^Vzb@%|iD^k?ksO~T+np$L$ zX9lHLG@RAKHe~H;yThNxa~n0L(|MuPakcRI#fulP%FdkWGoU?fZWM>>@7u)Uf#-I2 zHI;S>nUKrM!&oZu{$T&BcL|?>bsK90F;e4*RK`GOjszT<=Pd2|?wVVc#BN++!U$hw zza9>}gm-qkI0S4Rbq=hu$9iMP9BkZdI>S#8U%h zgd6Zf;oa^IlviJ{Ecy0aEjTHu_VTCiQ zSDo)OR5Wxh-sdT+G!yJ$UhF_Wc_EvP7cavb^M6q+6gj02BB{(PM`ZOLAvYelKmCpL z{pHkjG}=DCus4pVN$(IhSPNwa2F? z`N?xV6FZOn6OG)QiE}-CYJ@G@8djHl#aPSAGFv}nZqC-`R-}w_0oV|dWLC0Ky38JsLSs0i|oJyY58Op^UzS<5R6m~ zqZPQx1$VN1+7mL437s@F=;dB=AXh z4z4MX3Hq+{{`Uzv>$<^>i}_X~+awnBu02qjB+{UA%EyI%pqe?Awdj|jb)nwvB8(?< zbcFWaboqDhDJ|BZtMpa*jT?tyPlVXY=$KY`vmlPuS7YmWpOiH+yQ2>GEj;b-a`#vk zng6TE7kL&PCM%kE_-N4ko@2EpXU!FB%Pr3BMa%VP7IQ_I3ctzq?Nr6uP04-TrLO$st3?u3WsGZQQsS_vWBZ^8c>)Q&MUI&r`tfBaDYo%zG$$VGPJMq zKC%k92*v`$NDCmub=>SX0t_L`#%PXpfEC!@@CdGH@&kK8fy+WTu{}Ru?^?K7{K7nH zV0PKV)%Gc)UQph*y_`2oM7&*YqBfn)7ZZS+$B9O%M`2M5j%2s{et?GgPT6PV%)GnD z;zY}{Gk?9%|L-)SW3AJh;>>*QrVzP@RJ0QKxnnPeynQVGfY2|>^DAiBv1u3U>t>36 zA^0tm$@?n&ue|roX*M?L2LwMJ3mP=;Ezx%#+FM0A5XY|*SuXo9pP`KKzV<%WOF!sZ z_6708G~FCJ``2_Xt%w2@v2aU0N?|X7oSWZ)$|~rWwkg1F#mvN1aR5GO5#15>R*7UP zZSPdEz4m`%dH;3IDV{;9v@WbaKs>7N2nx3b#Y+gr{191!aJG!T3ImmQySyH`S3A7c#^*1Z?ODmPrmzunIP z>3wvpG@l4oMBlML!=e4;rK2vtydnBo-`)_3C{|?=JG7@+^$a|Vwy^DAjT0NLXHAtW zz&1#m7P3wE2+bM27u(1are*tOrx_OycjcjU0))v)poC+l+A+gUl17UU2XY+YK!#U6;%YU4j%0es$xxfOXzzCw@(OzhG)dlbp~uJg0zU@9T~NljSJ`u z+0bOn?QH-~7>0s^!ib_GL71b@<>hRP`;%$;w983C;VH0l`dpg9Rz}5{hF+?tjvQ~j zs8~%H*4QXhu5W2+8D>AF0U3A*Ux%fdFyYW&`uLV;+6l(mKaz4UT3S?RRLi?QHS02^w>6O=DP82THF$y<*C8)sB#NUDv5ot`|5=%?I(gg`65gK&}6R& zf-_%aj6T*JSUu0X$?k#x*6%QsMyy-sc3nZ_m;%4rY1L|Ynp}=>%Bg;YAg;~fa_5K5 z<~52J{w@)d)dW3-Mye!OF4XJ`;>t~Z3)x$3Wfzu1?2apDsB6N_oSd@nj#C38l{Myf z_)}`IqomUjOs1_$&FVjoMx3S;t^aB!zU2zbjj()Or>`V}gsDPu*`hx-M>*>8QrOq& zgLjhY0gl8Qn10`pzdnLA#j@IVRVF0&9W%DBksh6rhR6VH+Kxz?tMB6rSeJ(bclkjm z-RHgbRL9r-N}SK@mG%uPYOK%L|3ycG(=hUKgjoJ(_ivF{^IF#pWj}N%^0;w9aQady zXRA%NP8CWh8?UETz_(!>5V;p{WiX@TxkWG0tTLyy?*jh%qMrGPDG$6Iytih23l+!fb7;U_z7kO z-ya1(wy2H4O)(o_1UU&J3DCx+-+rPS*C1~ zxjJ0Qgq6S&8m{$d=JK4mEF@X}#}D>ZG91cT&mc)v-kJbWj=pccdl@-&dG*%E)D> zG0!Y~tXImM91Vn&Ao1J8z|p%?>%d{xG4VK=1K&;)(+^&l;t&jhy@(szP&Ebn8o{4G zjH(bV4?5o$K?)GLlv$>FI7pXwQ!&~F5(#N{GfsSw-4PzdJc7J~QaKmyr)c+x(cd#b zKh6I-x5*sxGFKN`-R3Y;2mx=hVGRQ#u2fVXp@JPX@$5wxBfLfpM;=C(y^%LX4C9O4 z`8JROE0h~P9>KlmLTSz%{jvPfx1Zv2>F?+G_0r>+O6L4aX%#fmzdVA;1Bv#r0o&zg z+1WZv*0qme;6U6TED-NM6ItJK@Ar(UwM6lEdt~4`=|>;Ui=)5J=w3*N3gUQQz*4== zuh6T*ebLwJ8)9QL*NNh0UT(NZ_iC;14MDF9dnh;w+oeDQ3O=#=4Lk2ioEG;$0AhU9 z5O32{zjI^&iNdSv%DWYl4~NIhx7T-Mk`+3HjZNcir8Cpx3Iyq-3TphaR7&;q4VkbpCVPK~fks>|b6JpD zbebBcV_uQ=vT0+tC*oYj(+1RC(sLZpP-TO%Jt6 zx89nDOb%~PYLbSjhe2j~Bbk(cHW<~BOxZO8xTyctnd|aDtrXH!T|K=#-IDz35A8ui zWvRfmdBmXBU9sT%{q!`x@I}K`0_+8sDkLR>NGY8;X)Cdiyxie*!3C=lfFE23VnNc8 zDP^tsfCm)GvqhUfZsB+|QZ|FsA+z*$u5f$}V6=p?g0Z1GkX(n)Lz~Q?%w_C2x}o_m z#wlQHXDHrtDFJ?3PsR- z$e&UCMflyV^BvpgU9rKmRO1yiKuyIu``tL}85s3*U;zZJ$4!aV*twvthETgb;=BX)XUv~wM>;2sd2(xhRM>yWse*-zz6`u3B&1>ojn zGiaE!J$E7ge$Wy8j)BMpd)_mFr}-<6bnWLJsu7fMghqnJ}0EoAG|lE$cqB; zYpL7Rzzb`T7PfL_?78sPy6YEebBhF=q@xMA-w7lm&I&)mLM-*bD=X2oIHSS>_Tek! z^=8fug>t4>Hi!R(^S6wwH6q{&r!Ob~H1`G^3t=7!Eio#AC^|!docVMHuL}F!H}($5 z9yZJi46j;4F*(I>UIoH&y|V@=AFBcI$W%L~m-FvbA;ROIiGBD>07^`N^oIML*qf|^ zMZ8|M-bf-2PCili>4D3xxF5$Bzmu7jPn3EI(8lW0mGU_mV(CN7p1~U)7km|r1oJEz z^Dky4F{@2rF22+J9<^{^)}S%Y^*r16{1DkO45%qX^Z!^-9x+G%0K)g`x^_0D&j{;j zl_xr2IGN?-LT^Pd7-uz|7U89a~1{P3p{w@w|sUNbo(>F zFxrXJK13IRLKQ;5Ns{%SSPb6iOpjK_Q!NZ|j9D;I&NZKT+)n4*vUXew1R?}FPB>M> zE-(|P5`TN%-TZb(E@+mDf?6Y_Z`&vL*U%{QpiYp*uTsALfdSikeL(2x_Mk`taR)wE zmx5j!SzcinH#hzkdh)flHQAvzHx9E+@zoR0+)~t7begVqrJzvg{x6=f{o#wFO#cf; zs3i~Q_}F55<3T)r;5U>LT9$I)ttr^lhBPiTU>VF6+Dg8@nD z7Jlr`lpE-6?iCm7)5p@Y)Kfp*?hI|d5K_(->(Kz^3&7%->yZNDr#Z0Lfk2Jax#kxQ z6KUSpplizK*dtO(cn)ufD2SN-0!bMLGRP!y>hmb?w0?5Cud{hi5gU|^J(N$=*!neY;SKm@5H^&QRpI7sLS7R z+TGT@fYSwUfr_n~mX?sobm&x_!50zw4YxBDesX*0%$9}iaMuzr!bb|mf`lPnZ5>ek z(#ffVoG>sH{!w1Bg7r{aM_boezt=_N66^8+=e`Ru;lSgvGFHQOw=@_`xV_yUcuEO~ zF~X1Tu__R)fB~g@n09TXIVvW$e9P)Kfx*hkC*7)6&iU>h{T7mFeak8z0{#idQtw!k z6?n8t>y60~eB@HhE=q}#h^-4S5Wsu8!(Ucb2IXMm7UX>k)2Ejs z6hRkPH^^7(<{Oqj!<4>7Vwno&$07$X~SP0!wT$%3#-3_PANS?;_p2po3A+GSAUF@$Z>JnuRZsTny& z&R={e*!7Ogj0W|IZz|_*%c_o$Y4?5HHbpfw`gFKW?{xnyod*%ZTRLA&nxk;9nVve6ZW{Vc=2pjY< zVfk~faJ;f*DW$==`|n@WoX(2|MDEM~glLaerRU+85^spZtxA8)K-t+Ro%onZ6~OGV zU;=ceerWnAGq776^n%KrIM<|hpfNjtd?86dU-F=TT;kNPP7WKGz3m3r{RF?oB2jnh+uMg9^Cyy#KnOq=+S*0 z4wIF?6ZD3yKEQCuUgP5MN!0gLb!(?!PWL_(YRNqa22C}@a+%{!yx)wBOr1Q!%?DyZ zoo5Tk6tfMMJox^*M}FHxcQ1TTcYk_P)qu%`%BoKM72 zFK?%5IH20XOs>vfy)bADHmkOge`^%St5i)~=n?~a!#a3aQiYJ|QOx^d4jo{eo=-|= z;SojFIOYpJLNOt@lN=K*Uj)#;MDTdNzf|J+^7!R_I6qn;C9pkqbf;o(qw#@F+x2QJ zL*)IIv*kaHvT`Ab;?`MwJo3zgG!#KK71m@^ygzH84g=xP9t_Ywb7Tqi^x%t+{9B=0 z)5l*0kthz8GhZ!jvQ{9q-Ao8x)8{p9Rb4|wz%}z%t;pIsEiD_YWbO*N3EXYR0fr;Z z^~>x%qNXBGVk`{wR)9(hciJX}f+K=}UMTDtxESd!cG$oPOct(=1LAfQdNI{5gui~Q z4>y3i{_VJ$YrVTytkOQH(|N3Oy$|l0**}SGJ_mFKTS!+_Hmb?|?*5GPqGY``y#f*F z!EmHh-~YenuKl0s_KiENM50Gar6k9YN=B2(vD0WOo-l`yC`?(7OB98Wl*3p;2#HB% zn;ceVnrDs~Ne+uSMp5I*ah`kY`$v5D!)KrS_4*uM_x-v**ZqE9*L7d-K41l3Ag%HZ z%D=m#6ATlY^-`aZ{A&?E7f#I<)u+Q{=H6ma30~;IsrP6+VZu%eu;j!Aqr%JY`4Ln* zDKSt=mcCey-NVcS_K;}b$P-uaEA8Hqk(m{qo?3h^aJ<#0{8CNx%?N@onXa@pY&za< zspS59s2ydiS2S=KO&Df;is0LsnHv?u3MEb{{p(bhqp;rWy$d2iDl ztHk?rm%JUWhR(Gkpcq=uT1fPWjpTIF@pLCY81d*~tO4Ol3>OEATIuv(=J3UV>p9** z^Xsx`78L^+?x#(W{ztRI5U~^SaeqRMvwf_T^_fMQj zOR?z+j`oxM`sNIf+;FXDQE6+6w3Yfk09iCK1<(P? zy3ElVeRS4kP>1Wzv(u4t5kOa#&gh0Zl%wY6VI2avG&#AG%jIJFYO{1LHdOLk7 z)gcQ&%T{r0q;vx9aw)&h7Y0WpdOBkqsgLTZoc6q0S?nTT7A%g|V4g(Hb~(B-Zn{9t zijX5a`)#XZM7&zG;=#hI)O;fx;G1{4RqcR}_J`D{SG$XqsU=ikTBH>$@(uz7e1;8u z?U?VR1=BUAPcCl}xLsHba%tWCuLH)RGlt2gKOy@&Xbb}BFm`qEh;NU=TBB+iry?h> z!CZSxuRyf`Ae9SKv&>-EN_};tU6&!vgL!pT#?(|pgsekSDP;3}(DD?2PsAabn;BZZ zv?Wo1I^f5f24?o8!hljno31I`n$&aoR%Fij7loXOo4pMP+$1d5qY+Om<5UsavfxMb z^v}L^Qngkw?r5-0041%BInt&Up3YL|9WO{5g-=Ty7FdwzKa(>`a}V=-WRNHRuqM9s z>Zo}MDBYg!@LZe3KM{V2Z2Nw4ZfkAGkJ0vfaba^@C2lG+89Uyz_;;&f4yMEkeX?e}K-!VzOm25ufBV3`JNq=VOqjGkCoq}^b-@*=y`kU*~| z?PQUG{8Fb%zs5gt;-Z6hJZbFdAU<{?oCm^}>)J6E9_R#}*`**?31X}MfZ8J;{j9R` z@+Vc6ox8A5wy!~Th<|ixssnDS+Xv(kh^XQ2_>t|olx#%xY`ZwX^ic?zp{5*!j2zTj z4Vf@q6Sk!0OpM?;rdwcn-9s|W;5NT~f?>${GYlSel#XBIQpC_C<;NZS!FBQXVlKVj zSHjXzxl1}q>+_aZj0)aVwldPKjekyVduE7B*>NuCO0X9}4T&3X{%bFPDD(mQVGjS& z@~vA_Qzb__dpm%{=bNuaa|V|r6^xbAQ~>{EHc$>aC0!h_cmnN2dq>+9 zwmRX@rWW~78B~~Avu%Q=G)O(uMK+9G%1jzqjRXTvWn5g zl3G|+!4^dAhH6THI;3KjmX?qhF+d5wwu?&`-sY^$e5uV{D6kwfu`Ps-ik92T+fT%= ztw8W{x21r2iWPR9k)S$wG76ltr)CakK^06%~a<8rhj+HBL>D>|!lByvutdEfWg&EZuXOdR{5 zK%01jYq1yT%MU8m?O|G?v4}Eyqm>V)g+{BjyL$KXwXn?RU+oU1Yh_qN%nyF(Qke=*`xc0n9>ZePVMFU*@-O^T7 zV%y*SYVmWcW_rR9)}KfgBP$>qZhCej1@+ZcDNMhc^LyOwr8oaGWy6oReoAw@-*2fk z#7!?~nG$W>7iA}c*X6^O0x!r6&65k DB4K5A literal 0 HcmV?d00001 diff --git a/src/openmp_c/1_IntroductionOfOpenMP.ipynb b/src/openmp_c/1_IntroductionOfOpenMP.ipynb index e32eb47..06b4ea6 100644 --- a/src/openmp_c/1_IntroductionOfOpenMP.ipynb +++ b/src/openmp_c/1_IntroductionOfOpenMP.ipynb @@ -5,55 +5,79 @@ "id": "3fd7c2f9-f29e-4057-982e-01836c6c6940", "metadata": {}, "source": [ - "# What is OpenMP?\n", - "OpenMP is a standard API for defining multi-threaded shared memory-programs. Which means that each thread or proccess can have access to all available memory. This doesn't mean that this is necessarily true but we will get into different memory protocols later. OpenMP is a portale, threaded, shared-memory programming specification with \"light\" syntax. OpenMP behavoir is directly dependent on the OpenMP implementation. Capabilties of this implementation can enable the programmer to seperate program into serial and parallel reigons rather than just concurrently running threads, hides stack managemend, and provides synchronization of constructs. That being said OpenMP will not garuntee speedup, parallelize dependencies, or prevent data racing. Data racing, keeping track of dependencies, and working towards a speedup are all up to the programmer. \n", + "# Introduction of OpenMP\n", + "In this section, we will first introduce what OpenMP is and some advantages of using OpenMP, and then we will introduce the execution model and memory model of OpenMP.\n", "\n", - "# An Example\n", - "The following is a example of a simple OpenMP program:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f8f811b6-102d-43e7-8fca-e36e2852f4d2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n" - ] - } - ], - "source": [ - "//%compiler: clang\n", - "//%cflags: -fopenmp\n", - "\n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "char message[] = \"Hello World\";\n", - "void hello(){\n", - " printf(\"%s\\n\", message);\n", - "}\n", - "int main(int argc, char *argv[]){\n", - " int threads = 4;\n", - " #pragma omp parallel num_threads(threads)\n", - " hello();\n", - " \n", - " return 0;\n", - "}" + "## What is OpenMP?\n", + "OpenMP is a standard parallel programming API for shared memory environments, written in C, C++, or FORTRAN.\n", + "It consists of a set of compiler directives with a \"lightweight\" syntax, library routines, and environment variables that influence run-time behavior. OpenMP is governed by OpenMP Architecture Review Board (or OpenMP ARB), and is defined by several hardware and software vendors.\n", + "\n", + "OpenMP behavior is directly dependent on the OpenMP implementation. Capabilities of this implementation can enable the programmer to separate the program into serial and parallel regions rather than just concurrently running threads, hides stack management, and provides synchronization of constructs. That being said OpenMP will not guarantee speedup, parallelize dependencies, or prevent data racing. Data racing, keeping track of dependencies, and working towards a speedup are all up to the programmer.\n", + "\n", + "## Why do we use OpenMP?\n", + "OpenMP has received considerable attention in the past decade and is considered by many to be an ideal solution for parallel programming because it has unique advantages as a mainstream directive-based programming model.\n", + "\n", + "First of all, OpenMP provides a cross-platform, cross-compiler solution. It supports lots of platforms such as Linux, macOS, and Windows. Mainstream compilers including GCC, LLVM/Clang, Intel Fortran, and C/C++ compilers provide OpenMP good support. Also, with the rapid development of OpenMP, many researchers and computer vendors are constantly exploring how to optimize the execution efficiency of OpenMP programs and continue to propose improvements for existing compilers or develop new compilers. What's more. OpenMP is a standard specification, and all compilers that support it implement the same set of standards, and there are no portability issues.\n", + "\n", + "Secondly, using OpenMP can be very convenient and flexible to modify the number of threads. To solve the scalability problem of the number of CPU cores. In the multi-core era, the number of threads needs to change according to the number of CPU cores. OpenMP has irreplaceable advantages in this regard.\n", + "\n", + "Thirdly, using OpenMP to create threads is considered to be convenient and relatively easy because it does not require an entry function, the code within the same function can be decomposed into multiple threads for execution, and a for loop can be decomposed into multiple threads for execution. If OpenMP is not used, when the operating system API creates a thread, the code in a function needs to be manually disassembled into multiple thread entry functions.\n", + "\n", + "To sum up, OpenMP has irreplaceable advantages in parallel programming. More and more new directives are being added to achieve more functions, and they are playing an important role on many different platforms.\n", + "\n", + "## OpenMP Fork-Join Excution Model \n", + "\n", + "The parallel model used by OpenMP is called the fork-join model, as shown in the following figure:\n", + "![fork-join_model1](20190720101130709.png \"topic1\")\n", + "![fork-join_model1](0_13209261094r4F.png \"topic2\")\n", + "\n", + " Drwa a new figure, merge these 2 figures and shown the barrier in the new figure
\n", + "All OpenMP programs start with a single thread which is the master thread. The master thread executes serially until it encounters the first parallel region. Parallel region is a block of code executed by all threads in a team simultaneously.\n", + "\n", + "When the master thread encounters a parallel region, i.e. when it encounters an OpenMP parallel instruction, it creates a thread group consisting of itself and some additional (possibly zero) worker threads. This process called fork.\n", + "These threads can execute tasks in parallel and are uniformly dispatched by the master thread. There is an implicit barrier at the end of the parallel region. When the thread has finished executing its task, it will wait at the barrier. When all threads have completed their tasks, the threads can leave the barrier. The master thread is left and continues to execute the serial code after the parallel region. This process called join.\n", + "\n", + "Thread management is done by the runtime library, which maintains a pool of worker threads that can be used to work on parallel regions. It will allocate or reclaim the threads based on the OpenMP instructions and sometimes adjust the number of threads to allocate based on the availability of threads.\n", + "\n", + "## SPMD Program Models\n", + "The program model in the parallel region is Single Program, Multiple Data (SPMD). Processor Elements (PE) execute the same program in parallel, but has its own data. Each PE uses a unique ID to access its portion of data and different PEs can follow different paths through the same code.\n", + "Each PE knows its own ID, and while programming, we can use conditional statements to control one or more threads.\n", + "The commonly used format to follow is\n", + "\n", + "```\n", + "if(my_id ==x) { }\n", + "else{}\n", + "```\n", + "\n", + "SPMD is by far the most commonly used pattern for structuring parallel programs. In addition to openmp, other common parallel programming languages, such as MPI that can be applied to distributed memory systems, and CUDA that can be applied to CPU+GPU heterogeneous systems, all adopt this model.\n", + "\n", + "\n", + "## OpenMP Memory Model\n", + "\n", + "At the beginning of this part, we briefly introduce two common memory models, namely shared memory and distributed memory. Shared memory means that multiple cores share a single memory, while distributed memory means that each computing node (possibly one or more cores) has its own memory. General large computers combine distributed memory and shared memory models, that is, shared memory within each computing node and distributed memory between nodes.\n", + "\n", + "OpenMP supports the shared memory model that reduces execution time by creating multithreading to distribute parallelizable loads to multiple physical computing cores. \n", + "Before the support for heterogeneous computing in OpenMP 4.0, there was only one address space.\n", + "\n", + "The following figure shows the OpenMP memory model. \n", + "\n", + "![memory_model](1.png \"topic3\")\n", + "\n", + "Let's introduce some features of this model. First, all threads have access to the same, globally shared memory.\n", + "\n", + "Second,OpenMP programs have two different basic types of memory: private and shared. Variables can also be divided into private variables and public variables. The type of the variable can be defined using an explicit private clause, or it can be defined according to default rules. Although the default rules are clear, we still recommend programmers explicitly define the types of variables, because using default rules does not always meet our expectations, and many errors may occur because of the subtlety of default rules.\n", + "\n", + "Private variables are stored in private memory that is specially allocated to each thread, and other threads cannot access or modify private variables. Access conflicts will never happen when accessing the private variables. Even if there are other variables with the same name in the program or variables with the same name for multiple threads, these variables will be stored in different locations and will not be confused. The specific mechanism will be explained in detail when introducing the private clause.\n", + "\n", + "There are two differences between shared variables and private variables. The first is that shared variables are not allowed to share one name. Each variable is unique. Secondly, shared variables are stored in memory that all threads can access, and any thread can access shared variables at any time. The control of access conflicts is the responsibility of the user.\n", + "\n", + "The other two features of this memory model are that data transfer is transparent to the programmer and synchronization takes olace, but it is mostly implicit." ] }, { "cell_type": "code", "execution_count": null, - "id": "ca50a923-7866-429c-9b25-00bd7c69637f", + "id": "f680970a-dd01-4959-ba24-f556f5a85265", "metadata": {}, "outputs": [], "source": [] diff --git a/src/openmp_c/20190720101130709.png b/src/openmp_c/20190720101130709.png new file mode 100644 index 0000000000000000000000000000000000000000..d9b6be52259dc5eaaea3d4207afa53f368a4d2a2 GIT binary patch literal 65467 zcmce;bzIZ&_dlwDGLhIQ2a=;p7$Mywq-zQY2#gd#ln_Kp1`HV8-H1~uMM4^+B^6W< zX(W_XKf+&fxhb z!>Li{NDXL0b`NnaQQS9@{`2Qx$n;;&z-vWk?f-f4Cx`RDx8eTc z74g424FCVWgZymsGgsy^v(z$I2xkG|jTytHA}1Mm-B=NY6klrY35X|%GpMzJhcOd$ z)4tzkW;D_S%|Pf+*=O5SB7+YmZBo3yPrM2gL8Qp&bRW zD%O+bf~NZ8P>jRB54+&t5Mz>5NX;@eh@^gJ3c+Mj>fZ~$O>j;IOo=PASt|FTzX{qb z^&9bz0j+_~G(p?rH_8a$P=shg5kc>{Ab70FCe+-A$TR&^$m8hc05=eXRAqKbcpCaytVIg|KaZCK!uHad56zWv-uR zW}L*}VoS}=K0aVozq-n|NkbV`KDw z-t%_bHt(bKC2^7Rt(Br-LveNVxg9zGD3|<9JX$A?ct(D?kxCHJG z$YpA33g3ePD^^QPCm|2gC&_!Rj`7$8{swybPmyN=?D22x@qU}zGZH|p2!h}xQNd>d z%u=tKU7Dd&KZmv?L=zR+6sgIZd*NT|@Q3eUqGM|(VX-%%k!FwcLP$tGykv5Y{NU;Fd|ED?|)QN-2N?S2ZHK$U?M zZ&g^e2Mm8)TO+Dqx!|i&m#$QyTku%T|2zkJ1C}q1ApV)j^YbCq^ZKNq|7FUcLHHol$7lC!Ii@zD!Spr$AGO@|6w8C5eXxSFXBn)p91_ z?c2AXKYu2AkecS^4@(2-Oq3UiE{|QQ=sx1cO!24-3KAOB8jmX=V4+YL9*KhxbRg$p z?UuT_XxFTZD=gh`a2U%8OB5NJr(1gf9`#yBC=GgyrLA zHiQ~JvCOr%h7v;w3<0T`;|0e6>))D5UXewpy{K@*!>yM8y|IwfX{igY8gkxE1YG4z zfEt8eLsb_I?0kgt=?2U#K2gHIcLd z^x;;eO{vdp+j%^ayDt}9<@#hLxZRkT814W!VBE~HKfLAkjsl6{kLHS2(lof^Az2jG z;eHgjzof;JGGk+OQa~7ixWN;dC=fyYFZ%0@GJaSY)sxyp zN9cDDFGPb4)sm(Kh+Y+sbg<}_ua#>UdNdK#o4PGU&vWP+IJt27NV&6ph$8br6CEen zQ=-VgVu2f~mq}WrzIXq=M5dmM_YdfVz;lVw1lR<6VW*ZmI>rB~|nwPw} zFuAT@aqB97e{+Ge{KmkFtdv($oRB}CSt{^>W~pK1GzbJ(VhYZx+J+lxE5gFUTL!tT zHjDW=ht9`KznyW+Uv!@)Oyw-uC$_9VZ2oFrYl*33{l&JZy${uWPeQyjG#Uw~{NXFN z=j=pW3MDI+8xP5Agw@e7*i3A>&PVN!z2A6MoV=9Y?a`n8e*S$WG;`s2xboEN^x3U5 znzhfKqBwp+lbeQd0Rd>f1_=JPn8j~K90XcPTB(}!#)?kU%kjJMYzO2D&6{+`_nl8g zPqVL_Y5lPr!4)-KMQYmP`GIcrMJ96H_|-NzNJ)qW##~SkB6wd&Q=_OI6=OW`&7o^# zxRGU(eNI{N^wGilKtq$yIkM6*#xbM4&26YKO`P#1)dto%eUgrBG8DFWC< z2jl9`1S~VtWXb)x8b11*CKch>>XOLZ&5MQEK7O8mxX(VF1n1weIh5QzWZC_~qA61M zjQ>$&c>&Dc%-(D!4ssSc^3zu!ngm1n?;_*DMTXQeqH&z_f!qhUeb^>LZ2wREBa$x# z>cNtRjBdZm!iQK|8+T-bj!s2)4?4mI9Tc-ZCmbbZj*|G?tH0uX??$uh=QXquzJV1( zhPkjpImDDBA+w^QowOf|OK@aD3hJ{$Y>d(NM)XEY&s@y9!B zP2rG}rh#;tz_jm5+dM&bhe)RyrB{RLgLuYz*87TriSIbm*@|P^INWfVOTJwp$frIL z!V+*U2MbLg-<`Qda3&Q7Gp=I0PKS>i2yD3v7S4cHQS}!(zb1&7nNu^sb$qL-l<3)1 zJYWd=-Mb<)p-f4k@1jCRCvuIx%ccH`48_OGKCBrovp0#$t%A1&zfgPiysJ)5@66p` zoHu6Z&^%}E?ZrBSz|cGL ze|1@YvLiIhG3s_+dT;8DJms%DaP)sm$WHnUSuhTh>wJYx;~+sig}3AES?NoQ`6W=4 z2w+Uy?6h&*{xnbMGVoWg+0=J?%Gf#jUqD9WYlN2fQ{9C!{7TDP--#;Kk{MI(rKwOH z{%m*j9yl79c4%Q`~cy}xVS;6f~lz8N;6d_pYU3EZ0i zMj4VU7Nt&xY}7k3#JF*d5q+ZlGQu6Z@diA(?SSnY}2n`)56Mhd)E zUL!>a&+uh>=nSW$p(N*4|L@m14MCx;^~aQa%QU+q^Ec8CJ)s<;av|buQZCprt^T-9 zIp7ZIkb=pH&I)(S2_gH53Zm5$I~Du^gg;c3ukOrt{FOSr``dpxn(0@*d_Q?^E%ge; zQ)x~rEPZ~v; zv+UQvxz=x0Y=51l^vacGymBQoGgB2+PKX9UNP;;IAoHy3e2lLzqnijqEzPl9Z5$QR zc@g!)o0WJIzGj8bNs0HMW!9jI24EY&9z5D_&CA!oMT6VV z^r{zDN8w;=as?Fjg~Aee24bkA;nhkyrUa6#c9z^afPQfYnESQ!a7}H41|GJ;A|#|c zC@KtMdo4gs4ZADlyddd%+@i5T{_FY$GcJDHlz>b^jn7ZHmC2zRiPzeBj)Q}PBZT!V zx5bKsa^J7y z*JTSjzQL9mm=Gt_SA&1v(BQ9h+QkPniI!|#7$hDb(V3A+>|&`YBsn+W)Fd5RIoQ8{eB-4t}w2X z0Y?q6oh`s!z!)Y8mY4AQ>1KD2T32`-bvM=IAhlonO+YHICZ2z(C4x8eIgQPG2@d5Ca5!?k1t> zhVhaJ5iWzYsOit&^(TMF^UEgJIT7V*)>?$99@#LTh{a-khAcTFeG*PVQ%*AAQT$F~ zC;N7Cf-1=oa7+g6+LnBlQw>hWeELuU5UNl7vC1N(^p zGvbSBJlDy!?S82auV?KR8^zD+)4ROVA;Wo^e?)BAW#8wTgf~*?3C0UbKNnmW#r^(G z700eTv@y+6JPP4@inGNhTuCc>Xayw??Gs;;#$#q-86sLo$CghCB!%YG&_`di{PpUk|y+A477X-ypItk;|&dGZdp0 zm*mJ~Iz!Yi#|VWwZgy+*(sSNCc2bMc+O3-)@saeQ>YxI0*%Qx^fWu}Cm_+pN zcU67mrUm>~R5@zKKm>DYzw*v1cvUdw{^0J|A2<9itA|#R2J~0N4GWW@ORq0qu)h6J zsI>He7k~gseKHv3Q?IzrNSfWp)?R=2T!C|_f63mJy=8(rUcDkC-exs&D$qU%z5MGwUAK^ZJ$zYisw5g~|FG=jQUDFC&HR zCBg=T@AJh+OLYvz(H55~%aa0+a`Wa*$PDJ?c{H?;q1Z&9#Dc9?;ddR^?l@oE#4?4E=al4ymQJJZB>YEDjVWO#cuG#uhjNkZSq~B z@(`cS+nyHDw@LKD0z8wu@UyD`2fH}MV3B9{^1Y?5aT<$ERsQrx*%Cx;eOoJyvD#3PI*jx5%lMD(>&u@xH+tB+*}l?Ds97)E zkyH2k0=T74EUE$AmWEH!7R0@wAGo3-Jn%^nf+c{)UE+e_8nkJVFvo+j`^4q3t zR4h0g-%L2^Ur9K$=xEUG8n2`svc@*HvzT`%?H~tF_Bp$OQ^4+~kIZHG&Cz0UM~j%x zS_a6{JlddhN`g{G%i_~88@L$RCoL&-LpVqrxxK-8a zH~EFvOLQq7!vB1{G+(>kHSUbNB3g{Jr~cWabPD~`g|z%C*)=%?Gsx$(X{3nNdd#}f zNn^_%0Lfepg~;VW^Az>{4k;zizYfmy+ZNxvf-cP>Tf4!bIirT+muCeA1Oj*(pgDTI z)Pt|{4NxJ}9zMdsqT`A^NM?j)GuC|Hu_yO7+CU7iDpJ zyyw#`to|jXzXE}z6wbsyot8cse_Qf-&8x_Po$=Me(^OOQ2cKFtKM;Sg;P-E^&VGEWzZ$B zdH%Uiue&CPix)1PR_1joo{%w`_KCgV zw!GN$0)DZWT_CInrs#z`{;{5`f>@lwyO6*|dJ*gI+{d#P^Buz5JA#&zy&II+kifNt zuFJPvPEYb-ca+J|VG$vFjkY2m*pDx5Z)kYSs1+l=(LOq*-Kh&=^4jBg?4JAg&Xd@! zuNE0*F6iRqOMfD@`p*8`^2|S@C&98S8J^rfP4Ju(H;>tCtg4O@9t;(Hqz2*{Fsj)2 z={R`U7Tt_AoYX%tdFdi-&N*|y>0ofjRG4x1V>RcYYiXaXl2^*KTo5A+pwBG98j0sP z<31uu#XH=aSDcN^?$$CLHol!%N z>`ZaJB1e-ib>`3Hldq!c3(wDfPP(2hiuMN0U8?zhO7Uvh?R&vt^8Mt%U#>+`2hN6c zwTPJQRg2}<1>yqwWVzOC$+wl&5CL~LA#|glyHli?}pXG-j_;QrO&W7%^pB?q|Zk|y$N^mzF2rjpY zf4S9)+qly$ytyC}&2rRsX|P43WU^gx8&VT|;oE1mM;AFFHeTH6+PDKON$o_mHR9|v z9;rp6Iu5-fuVr3_bk&i-;%b9uUs0=>kj-Yu))W60oLIq3JW?$d~#9SJ_?TX z+@_sdn)EabW;u%L;n3`ezf*F!{HVNjd!_!)G4}(pveV#}xL=fg!3(z%-d~via{1$( zql-0f&l@+;0csj!Xie_>f)EWT`@bh_j$hj0oge)ax-EG`ouIIpDAHVp(-^wo_y=%0 z^o^h_Tvf&g6P;Eg`C(*FaJnkIkh{(_15ejn z?9jda8mD4o&LPGe-)p65oTm55=Yy?t+n^qMx+4Hno1~w*l9wWcUvm)s@4i@1Kxwqa z7p*^~!$~J&qH2&I6W2dTx5OTet@J9L30Q9T3vS;Dimh*mRjhxy_s*epM|L_nUbQl2 zg38G~*Y8lUv6+;)om^7T>5O)HR(z*AIU|*aUt(}aX)%%fl4x`EU`0~kvTK#viPm>i zBkP7~JjRek16?RQ^1=N$KbU6!MZT8$IkyL`#}?D+%JJShC~O`7!|4SYJFpq!a+RTS zsN&-UzrPF)uCSwO^4^vM3x_hpX|~zmJq1f?qfa4fd3FZ5+-JW<5w8R1-wR2et+c*Z z@MQm!9B&uLMuslwz2q!9@?=-Ex8+#Ys5fZUwBArLO126gCj@O*J`=y^p}r9H!VSA( z!+S;^oPAu^g5PU&K^KB};B0elF77~1EYlC zBIZSv+2dcndi7xL*gx;_nm~<$vku0=Bz~1hN<6yDyS_WJLHY)TT|D8yk$yLOL!nc~ zyMSC7YH9E9r_dD=BH{}Mg5Yd7+d8EtmWb6}SmK;wVS1#@T zw$_$te&K1cvihTlAAhLl_L#gebOFcw;u2vei^Un6XBmBGTZV~Wl>VG9e2!#q3p(b+ zCEj+W!&T;KWMBL?qx#s|19#r~`$gx`-}**SjM%P3MhzLvg9pK{%z2F63&`j^YPYns zClk;e=}j5jOMEXY7IAegVyl0>{Csmul(+mel;rWM;MjUmGIPK&#LsZ|igE}+t@1u} z$QseKMe!?23nx!H|Kfg#S3Q8^kFBAq(Ij369NTNmxVh$NW2Si087(L)#^^F_> zbFji<+TC_~60_&zg$Iaj}{_>b})EH<)wvGXtaJ;#R|h?HDY3EADLc^1|FqfijiGU&7t8!SAGE^Jo&$H`XdHN738>JEX;NO8>yzl(wpI`lQ6ZmI`v zgg1lz;(r#A8LM7lg3AZ6AHE4e@mupR%+5CM6n7$>{9yqb&_7X;b~5u9FD&Vkm=EY9 za7d1h0Ai{Uu+~o(Rx>rRd>vE^7OJ(_0b>9PFer`z;anR7V+Za4Lo&Hs7ODec>}R~uo|io$&GqbWCG`R`tUX(*Sp%t}UXZYlr6w{Nd!=I1}- zr?4a#O(t&Fa}H2-GXqY@9*=|kpXCz*p+h#(EAIcS8mXeHCJ>+w!%1e3cd&>63^u4j zra6LIk3T43&*yZ)!w9r$9NjoCY78Z)AseB06rPn5%+MNnEB`h!M&ps@Zh-d1W1*m0 z1S>>ON)h=fP_2~ISO0gUa43Y+7O)1oLd1&tqJP}Kv&7Z{eS8Jy;v~Z(;TR~)9)g7< zyKP^U5=-@l#`HJ{sEQKb&;V#mj^$CJ2aQY1wg^C;i2zQB9i_Kf9uwoGcWPQ3U)OFr z)U7XgU1%%&4#LBI{K-#4+;Fp=-;&SZGo?%Y!3DOIPC<;a-skoko;{$Mp+UG<(^bBr z6}47(a<+93d!*HXnLq#q3LB^weFBV)A6J0ZkO_cU-;QkT2;P;?sNpy|`QEPN$?}q? z$v19mLpMaNu8T!hMaZTxTG5{}n#G>`<^7`Use=9hn7V_ciwpCTh#4%@qpov)jCR7Z ztP7&y`oMs=4m@81bh>1E#dRTh0vM6Vcorug_tYCwc6CH+`^0a1bdl)p=(2iUK0}|@ z+%}zrBR6hOYXv)9gxTqk0oqjdJUuk2xy+o8KD^YG#D~>23i8b+UW?ryd&|Z@98h=B zMYe)~E#g8m2*^LhC2+rc5C8J@D`G(W?}-wKi=fD!RW|pz8Y8n({vvB7KOiqGlKSC~ z5l%}tH#e)+pj^{u26H)`0mFy8E6DDuni@60in%gZST%Hb$}EPGvvCZFuQe{ezj9~s zV0&S3czC?=@ozy;DkqX{nVC%gDZc`$50G|%!{o%ay^p!FJ+s?JN;AS7-_x|!aam!j zjTG!ihj9R%2%t}(CGaRCJ6ru!Q7n(5SL$4Yhm*v%~!R7}-z(;NtIIaW6RMObvv>`i2c-$vhMbr06Q zNL{=R`a+gm0bygg2CuF~O{dl-+miyJFV)anoPU2gB{zwboH}9S)z6>qpiKV5=ZM~s zd@~iEnud&M2)|$uxPbwMQ;$!QiKA7V17s`0kQ)z^3B)43MH={EN5T2Q0~i|khylkq zIzGdZRqu?f?CfG;U1A0NU;Yh+0nf9PgZbVPIQZd%-K)}6N2dL6kJ!I?q(2AJ1iB5l z`I?EEsw$P%@6UvFK_v}H7_{M_=`ZjZ=9NtS1kM;FX{-B3^ctZ!4g^pnP=&QfLlP^# zC^Aq?{^=|Gc#r>^#}!zil)SvIMH&$;pnm**%p&iL7anl2aFg}jfD;SXZ{%{R$!XZY znt}>@V>26hF4wSE88|xNS;2-(7?~#rVisw3c+NwY2h;kw)PEM@XIp=#S7y1Fnq2%CW!^9w(3ta&l&y+$>4myn(wJm4?=uSTS6nLVNJK=yvd_V#)2IFqp~WV(YG(cHLz}6W5UaFL|}yp6~WM@n?^Af)C^&o3VpK zvn|K|^J{V+CeP^4VwEF>)ydUCVBPtCj0O+Wd~BtESI#2(g3nqJ&DSK^EUemCrsIJ( zeSM{x{ayY>T~PS)owH!Gv!BYUxfj@NWja`7A&91{gxNp`g}XT9LwWx^P#=HC#6|C@ znP%bSF@_|*=6%!=&Z594}9<+az@I5&BDqG#5A+4ucrFK zWzJ%tfSiJic>i95$h6n)Jy!I6JyBC%-|OLM0lbH4Hyo(MyMKq?aKhW!*@b><{C17_ zhPND0@iG+Frn1Ll!jf2Np@ji?)(H+I)d+uacXEpORwE2*CZXS=iwgKDz?KTbeY-gV z7)szoHqsoKEYhlP=dCRI4|(JoL>fHnOaV3~ue&q4=ob%gKGzYWm=+CUqDUh&U~S>^ zQJifYo4w%CM?NI@fG>_?_qD^F6GTmo_LBvYd6wmt&d;WNBZP~w+Ld7e^Tr3mi0x8| zu2_8(OG1(L}(t{j^DUW0R_i>;>`gM|!$Kp5R7do30z>qD}?$0sHc zSbwIpb9Vd)prtKoLEY&qN~D=wHjNRhDH+9)2{u<=2Q&3aSeh)>i=Olpz+~UBZ|5CP zwn7|37n!6Tr~`K3?>A2_o@$9gXX?-Cw{2wiDE&cB1Ip4d>S$xU90HO)Tgh$~*^t0J z%(NIYCT*Yd8}+X%`D!&eAfN4Ohj=ZX0||||bc|w9#v^rfCjKg@9`x%obD`0ND$mC4 zq(ROu;%_H*GXq4025G=m0}E#;9$QuYN!k)szQYKD6X-($`4-wy{8CD82rLH9c{qDn zm3Sn%f_^H3&K4W+5i!+i-#|RI>$@D|6LEOxpA-O`NQ&bPA*{BI%$gjOOBsYKV(W-0 zCx3DjpQtcz9Z(hA$mafyU!YeHxF`PTryg}cV4Qz>e<5Nie8Ma4haxi?n0};`3nDu7 zkwu-bMhP<5;IXi`j>k@3y##ifEHhiRkrjG=Gm6NdBm~i9X3sT`y?(e9BjEz@_pg0JxcoRC_!!6DZwWFk&tF-1?kjPx__%P zSz(O{aEk$I%((v(QztAjICO=+v=h$R@F*P0bZ?T9oC*mV1^Yj}xWz;jxiMAOwXq>= zk4?jktjj)@khSo*q4XIPG(A3lA-H7W1f~5piPbOvwCbiBHDmgXW%14pE7dO#K$&d6 z;_m#HFBRpy=g~8u=4it=>_x0g`J@S~V}q2RNhf3Q3Ea{G98E&ewDxUo9R2|}g@??^ z=5isNp4;;pz?z7SFzl>x@AU9076|go9?(J_L{m6YyESqz;8NdWdy$&pOQ1}ghwPna=?J*;#6jWSmW}aJ8Idt`%-_JW99>fpUuotPwJ7+|xWJ+mKZ5;Ihk?wd&a zJgHv#{pLQMJ)VVy1+;Z2u#L-GpwY&YQX0mfo;q{8Ka|f~2NI=WJ-IV`8iDsY((Rd5goT^=X9gC%n%&M%P5rtr>Lz`@NgIL#9BbWJ-hrx2toV`X7Tjo z=p*_)=)&t9O^}6o8t{{|VW_;cw6ye|nSx@mSoes$tN;%+HMJ2MblJ6s3{yI;;y7W& z;#`P(IbUYyI?1OS{ga!U6|WEFsG>5Wj6ro_SlGg2wK>b=Y1t)7AJn0<0MD;)%`ska zOQ{S`(vW;46BJ8r3prw-)$soP_#%FIe9xZ2P3uXPjZH2Ui!`{XUReO?W8HAzT4PLECt&Po} z)&Gv1oMfUe|HP@<01A6tDZRo1a!?JF-zSFaD|cR=;DUpHx6a?mJ5fJPzkNo2_Tl?6 zxj`0369nz3iTcs3#L_$&&0FeDqR(o)bophiRpS$;O+^h0aXykErv5R^%c|Z0!_B>| znb+E=sv#q479_v5&Y%dey}G*0n+%AKqLh?I>VrXBiZDp?Eo~j0+gd~yb_I^9_gp|1b||4 zZNbRfs7C6N5*BB?oulIgm|dbzMEeM)SruhYk3pdy42{ZL5OnZ~Oe-v22sInOEIAkk z!NW!eiztRIdE#(Y+6;}?M?b?Fb>=3*Yls7f88beIc9rG_Wu%O8; zg% zeX9^2A#KwgfJjBAO_i`k>g`>Oo^i*j`7C`pZ+?NDG z`Fd6jKR-F?GKk~C8mpjBjuYwp%8|DeMeHa+bm$S&k(UyS;l=xp$4b1dXOrWV-@nWG zU8}E#>ni8x2-y+puY8Vq8pXA#W0sn(3Ppu$6hCQeJ(>kx{!KJc7r$urc zv(=ytq<#JBWm;0h-6|}TuCpT08bn>O@q%aul3}EoMFl( zj!yqhU=E1_%bB zw)swptUEoSmsEbYL-8nBo=zqam(i=%rxjQ=>JkQQ{nl!f3)KK%`h46a_0xsn( zKwC_!RwT@-v5LI;BXA#XW2#|X^`=P=pQshjmS{5nP6zawtBj+Pc2GJ|onfTEW}18c zc3%XcQiBLLIxXicK-UC61#u;4|I@aE!Y%;*QpA7m!9*4RfcV738Rd zwU_ic5I9I>k)Y)9M)&tE<)FRRoyq;v(33y7aZR+p4N}wNd*g@G86^n<6jM||qNOF0 zd_$KqYUWY=f)o#e*xw%(MyhnYr4G;v$iz39K_e3CHo3jF@ZIc)BN{f(KO4ND9mm`) z(`zDOB~AD>4l+!urh*2;B}8Wp2?g;GTs3_-k7OF0wqF@^ue7ub`89QYo2uI$LbAkW z7>B=&(R;?qMU3sa*9ap%iFcVHoYgLm9>r%%d(;Fz$esh0DKY0)M)cJA7A<-@QA`-h z=HyaBNeXcwKq0oa!*&+OIVzdhuFEw=48XCr16Swcr0#39sc1-tkrJRNeh?Nh(8r>@{RA z8LyTIxOQ+x&!#dw610yct;kMR-g&kz*WzYYNK|+T=L4&}6|07a7ci8FjvSweCQrZn z2Z91T_V{wa=Hzq}HT0o4pw4gajE#m%X$)qSscK@b~?s<)6B@t{DlX+ zh@e)bYNAG);VZAPA)>RIV`AjU1BV=)NbD;Cp_y=;l|rkL_xksr+f5IaC~!bQKwC77 zm{@d8Z8pUc#3iCke|?(@4}3gq+f`N5*b!fGii=qS{goh@-yVAHbIRg8-DEQ8St>B{BpsLN}O17(%8quGF(b& z2n4KQ5ojZ@P6xh7q}!5_iBw~*_hBS_ZoqG|0U*@oaXSSz3FcTRtVQRhdGru%qc)@; zkDF~;v9QYJy4+mW-^E+3P( z%Sx%xm-ON0alBUAwfF;9+^KGsx{xDHPa3(aw)u$*0dQaMWv#s1r~@#7NKHfII+Z4S zK~4MPxJtCn<|jt=qAXuMUJ>`J#-|oKQLElM){`zKP9{44Q9NP@WnpDSrkfO1xB;Xg zz_V;(QkERoXQw-%%#7#qr9^%16b@^Y0M6rCHux3FaRqsic)! z+rccIqYncS>+|axrrn0-=}!8Tr2H!hJ$h)CTCtu1JaVP|E6!n7ea0xXtuZ8&M)^3Q zMwnQ01e0i)B|1}@Yl23W?Uo=J0{F$iQcVw}1X_`ipeVt*sd&G2ml_BGA6f+L2FMU} z0{XBbp6=(ZJS+K_U_wRM%hQA|Aj?#`b`XjPjFq9j{nFgdcQs?-&20$zK=BEX}5AJ!god7?u2kya; znoavnYbIt{f+LbqDJcMQbg$%lZJsL5JYE+;VKpo~`Y0l6BUXHl{;XPPrhZ3Sn zR&Wvet$xS_9S+26BOflUfw{B6sE}RYq0F8A*xaXfR-feqP8DeRy#ITdQn|)BLRnM>0layP~&nxI3Fr^^CnSia3G_GblOGirmZYBuK=%N?&c2@ zm@pfUmzh3k)&BaRh71MmgKl$NG&4rHMBXJQG~Kf&r<6)e3r=6*M1Vosf9=_M>D6jB zGGDI)mnjR<@CuuyE9_5H@>ZT~evk%S1n_*kV;@89XOWsenn~!@^gfQad5^&wyB+|C zG~M`s4#NWW0Zx<)G#bmiZiuR7#E>~($iH1PXrHT!y#qrXkc|7*7k3#q#1MAG%lQSP zoLx}|Q>(%AGm(!hPP_-h9;bh0-Aa=&lwB1Hj_6)t(dd^5(!4zeYHPvNIkIA3d zn-OmGc!T^p>e=?t1E*ceF#W7!*Z=MXXb&k}as+G@4gx^F@N4=~u3@SP3p@iJmiIp9 zy@QVPZTh7*e)MeHE@v=9cpm4D`{khmC0mKD232Sa-Vn69ddqQYw!g#6<~!zmndTnw zS|fA>3_m~uG@4KlMGYh!wQdPZxcv)#&2lh`=^1hbQh2la&ebAP4r2Jn4UPT zHnR{w03h5@Nq#uJw#Gao-(TZE%--bi3{V>!0Z@)jk14NBl~^6#N+}Kw6}tA6i6cvU zX$rd&(EIC-5&H?10NeHskBUDG4B~Aez;I&&kEpOd-DnqPNEQ^YpH?#hGJ`PUn^<#}jl@zbj#+aot!3z0xYZQ6{h7tdm(71;`s&5j*%(MWX0%PkxBv_aA@Avs8mrXu{A^ngKerhn6}4n75(}1$7L!_!gR$^5y_T`+h927h;RK&Z1p%t{Q{X22RF5@>-N1HQ-~FnD*FxBa;#05|;%PoQl? zN&U<)AVKoRO?~?YCPQ|1#3w9Y)(X>}U%`GmIkN4>r%U_W49Q%h5#6e+JB4eko-__R z9RJyor~DQ|G#p1CJS?)^7##{vm4&s-^?;NKaDzEsz_i8E0k}Jlz7TFdE2jA)*CUQ? zCIBSy-IgGw05jY`R4=%B01x*`vVbsHn(}#S3Z%6_D`QY?vW3Em-H)vv58fXvk6 zAD~@fAs$cNLgpodjhRjqfdB?pz!wd?(CkX43JUpf9rBH9?c^--@78^!M{fICYZ3fR z>Du@1zY^X*^+(du4gGDbL0o3&hJ%W_2AqqCZAn}SB_+aZjd5_U8Tpq!!2M5ZWC_~F zw)?AZ(i=nE?d5)!mk~*0HOO?MPfYVS#p}Z!HE-TvaaFzl`~`DatOliMi5Qcz#mV`z zS7(p-o1Y==;YY9+U&Mz8;6yAz(D^}&GrGmf$qxV}sH`=Avo3SK{^hG2D4#K*U9urx z3;8wXsttf0#LZxYgoLb`ABGz$pQK#Aa&5MG1q~!?t)&Js=d6f$<-x)_WQRF2y0FJNHvScz?JE9^8f-7z)+C0ao%q^O@ z8|8N&M7X0r*aX0sT|xXq!2sS!*Lxq*f|O4KjQw;Fs~&S27H(jM4Foxc=e%EkUDKQ4 z`(-;CpY7JctgMnb^ep%OQ89Ml3X1CERcd- zjVQ)9dE(Q*&uUm;WN&#qte7s@|3C{eAyC|cb*V^Q!X|*FFt@OrKWz?pveVZC=en0G z-vcN(cNH2sf>9dvI%V^C-$($c8^nJ9d%AzP)kz~OCpV9##S}d!b*HnS|5tqh87ZM3 z0o$4}qGajbs&%x`B-TGcBIC$36VO5ps~Qr6`@NJ97M~#L066Hg{~L9DVna$w*`+t` zCHp@?cDt@U$!(Me9LH5@C1-J2HM9jciG>p=5-BhzH`7#;lW3$)CCqP}sNL^oNHz*YQgW&%Kz{dZo@0YJKnX__xKI|rYI+zC3+ zEhAp3)g(`rAg!E6>Wl!iv3Jy1OX?>eKeW-$%S?Yww{%WSSX9_FclfyuB4C^YBApL3 zZGiWF{7g$H3Q$u>*(|YzTt}HfIHlsuRmLbJo*3m{)xl%6rdtBD--6zL>xX!mN>s&apzt4pHg=ak}Mo@3*j_KidH^&JovJ1!Im%&$=Fj~0vUe-+mN!3>q9dB!`skd+3K~@813F$E< z>vCV;mb%}zhw%6JnMxW!K8UCVM5dJC1U!je^?vblP6K5QUz(8KfiiP79JT@!#7)uQ z%K+SUr{02Nf$y#Wl*s)Kb9LmFj5BoZQobWFry=nxkho#%`g zi~mKg_}z=JJW%qgsp+_Vzxe~8d@}W(l?%q06}r=bfGibTQm|*huCO2@-$1KHVPRxWRf+CW0~}bv$(@Xz~EJ0lIl7EbZ}NwGzM; znCJ{T1U;1q9alfEs;7#4oIbafKYJ`#*xWPPeh0R|DVlw^h(KK*xXx=~2fo4M|Dx&3 zz?BC{yT zSjhBSkI(ma|LS#bmvf$HzxQ5yt+n_29CkUJ?1aTf3EN4Kx6rQ)lnZ4A5?dLFZ5l60 z#EIO=`RyoFhs!^E6bvJKD%?Ym0^!RPuce;6>?J`c4>Q^OG9r%cRC=_J`PQ?eAcv@d z0AdiD3G#t&ILKPIX)3XX?Yv-C^+b1xNW)E--hG4`6zUiQ7SvHApAn~hg?by~X!8N8_QE?UPvt zo0Anw;+d^Xf%m0t`cj)ov}CYqWmFi@jS>F{B(DqMW)9^oFm8@qC( z6J17|_S&EdE6B^gW~+)M)*}G{Ify|6MWYFU9lk3W^Y2|}^ZptsWIAaW>0f#7m&MT5 zi@QE6oqDmRx)B z_r!>l6@$Bo!1qV@#ucGu_S(J=0wB$4pP z_l%P^Qbcv=^^#pYz{Zzf)YQ>2+pHGKIa(0;vFHG?PKHn>ojjNB^2wyI0) zW}VaReQP4B%WoL9lkO0cxK#>uk?zs(5@SydSi4O7kZ%JIkCBf@SkCPVc39i&KP8u6 zu2r%^PQk4haKOk&VW?FJafa%(qgCogreIIAJdllvv*5QK)A#!t%EB9?O#+M z=BiLnMx8TY{@1INL1m95hgj@xK30WM=vksbB+Cn0s)N5%m5^4adwnOThq%|+CJ#wa z_H%mg(#AiDkX|#PElAeF&*&L?$p^U|=~sTUGjb{S zPn7gp679R_GtIZUbuPoxi5h_qnStc7E2&v!DH85s!UEe)*f6#ReZyqqz4~3XGz@@x zjpvpupbBp|Ki;G8a{hhIf2Z1ao(QgDNHC#}rSfP^;`HO?$vb@N>wD;Aid_dz5k%xcYIli3Nl}f9axGNxBDFN7nacB#Q+g*(pZc39AP+H^T+8NvvX zy=J}%ES^LcM4$B6h=%thJkyqN3xTJxjAXO&GHBXX^Lm%sJ$p(-S@B3mt|_X9lsOG5 z;4vsQ{GS#3HQCEAV!7Ob*lz|}W?KyhJ9}OPq_3=85kLF1zV863tpYM1NZXIQnz3GniPKalX|RtH6u(7{SE~sM*nGt6U%scwk-yaGxH5-5CT)Sm-4$-nolG%nLN|e_IEU7<9+&AEH#WRPXxgQr?{nf;8C;fCIe49c+@8MJa{DQan6T@5bu>w z8?c=1>9qllnLHHn`0x5Q88!vKuS^4put*}o!!|4tkv*+;Y(m)fTj8)VN$^g;|v-DF1<5)!~#KrNWm(#kz@*G zo!a1~8V;gH={7VBYrH{`%*n|Sm5{hWdc=f%CYyRqQ^-CN;+Mk8qVL}ajXwXg*Gf9o zWp&y6vAgKAj(-zaM|V&NS?#&|=uTjq40{f7^OtWEv_&!=foSOv8>&Aj<-ColnpNJH z{dpvhu+Dd`HqO;oq%9)?yS9^>bx#w2Q&~4M7Mag=_NyME{B_Xw-6)B+Qg}YPoir>7 zskiF&B@zleT%SID$`Gc9qe)P}E}4302ZJUTSk}f?wA<(0J|NY`El^G~o&WkiQ3fih znt@L+)6;pEdzTS zM#c{P9&6=WU2a}Wf$HvpkJh_Z7cktKsdenZN&orF0ST?J^SHDbp89UDMIxWB=7E+dV`Bu1Zfa4$%84p5&$3e$)WpVyeGX!Q!hXF zUr~(l^facKYc2?Zq1^TE`_&>Y&@ziP|9v=pcN|&*cpqP1U-{AJev8sgw6BpQ>u+zR zBcv(|?#Dg%o)sjL^Xb!s2d63RP(uO4DwlzcdHiIX&);`fKi^8y&z%1ENqNMD;SuJ; zUS#yi1Ni(?vXn|YWgFNYiS8UbE?PbIf}gjPWaFVIM-iI5-3uy17+5V%26?d1j6eHq zWjXTUK{y*3Rz?pp6z&n9zQ6RKzdnGQ`ROD-?JKqgiS<-XDi#HRjrT zed_i)O6H}^9Z!4YcIi^!d>ZH>EQyO(;<^Q0koiDLZPJapU!gN)7z^ZCSiz%)eSL< zPJ>bzNs_mHyFFq){$dhf)3@`H1Ks^Hx+XqqN2~9?XR{()pBFDOP9Ca5EjrE9u(xSD zWiAclN@YjQGz<+{Ynbp(YJFp7(_n4vm1OftIp~)d$2|Y@i#^%FdZ)x=tE#{I=iW7qt4uA; zUvBa)Uh3(d|2;ACJKR~;$dGQE_&sV^vKUQTBU`l5%SJivRJL^fe(|-f{;@g=x6Wjq zvhKYv=q;74UH>dcR6#)TrkKOA2$pa8&m%T!-#v0~!=+7jmon!omS&Yl0~0(?iiO@k z{A{=6%XIzJ(oZHf5>3osDKkMEJ7qLUd@+7+>b$}k)!<7i`)v_#Eh-^qF!qg?LESmd zP>qQr&hT)AkxUh>?w8RSqeO*(=xNQ=cVXJgJcp@cPdi%wdw6aGdHHZ=TuaeG2D6KM zI5~&&B~-C#;o-v1%dZIXZ?CJk7H6GZ?kD}GBk_vgf5nNqFEf+>EG>N#OTaXdh6r!M z?9|2`mC+8e9N6r|Srfq{Z${ zv4t{8QGrLj*)qree7sq0m?wZiQXd2Hx~?uZN~I@7jg7q!{LDmBqu|F2x79MPPA);C z@SfqPT$c*AfE-isiRz%oMCS*K$;=yi$m2|ZU$r~@+(7&0zYj!e*_4}yR=m>cribdF z8%7=x(TKN(h(EZba-Qv8oMpr`%aQ-=OAK#*$gg4C==^GECq$fP1+9X_!Og)Z_E5+E z{OkDD?!c}`9|Jx2Z>m#zTqMh}0~;ipzt>A+W@&f%h;;Y1yHQLd45cqaq{0~?7J~v$ z8;xxk=@QE|ia@6E@%5Fe1&2jAI`?ao<}voom$Dl>U?1f_uCB3f-W&<9q4;WxXoyEo zUrA@wp-%Z}Wb|k9XM8&LPP)!>>&{54!okX#i0AKJ&$(R}4rd}OrrfZRscNlNh~beH z7PvH_qTbmZDHRzLGaGf$?*<07h)tbsvH}SW zz?AyhD~U&%EwgI}yx$)#93UpDq=KKUU{mGnnXj%*QXY2nxd)WA_vppV9{n6IS|q<3 zD;2zR6r5XOhhu(+L7o6xW{VD!z@_qo4tpnzbTZQ{bFCuWSw|03!AGQ$ywaF7IhaN3QJc9{bj|%ed>Q_-%q6(tBksK*eAI`J~Hd31(g@}qVov{MIj*qU2TiemnaOmyPlZmwK^7$ef#!iRvED*TU1CB zsXgPR)BdZst-9^PKkJc_Nz0{B0?!9Z1y95=-%CMkV+SZkYP?5opZU)yr^kP3B2Gu3 zu*2^J=5dym40NWCu;o#+C&@lK^Vc%ReJV{^C|sXeo*OLsarMnlE5|VMF{sxvM$WeB zO1OUiAo8xBoW4u0m>4o2RwVn7_R=nC8uRuif5tRKMCEp zs6A@CXP}S6$LhquXO$VZv_!i8SMGsM_nkDch$5$y8JhlcNkuEbeKdn#pqDMqci`9Q?BIW5b|&F$s{m4|e||1MeJM?4RSaMAV% zk8^5&f0|e|F!sm#dcQY)F2=}1Lz#kkU%a#9O^`vnio43!DRD#z&d#2}vZHgBZdi_5 zrC@hJW|^nTE=V|IJmC}ZWbik;v$QMc5(^mS=4BM+>OFO~Rpf0`zagxF!CS$=l}U9a3}eVSGchB{jeHZ9r&jN35y3`oL&20(=DoPAZNe~80E8PXtS_IyN4B# zFbyw!l+(UBz&ZI8W(^IIAm$)$x`iXJe<|z7MjS#ob%ZnOQb|?+e!0oNEn@q2IQ+;d znV%fnoJ%lSn!(pJ^55y4`}Rml!UQu64X0+(=(ZeVO!O|HU-)RpQ>pQ zhT+2D>#t|8Nqp;tB0E_Q!r644hbN%{VW6Ay@t%3!Eus!2MQyp5a!5D(6vaXqE9*X9 zFv#n~f)O$=X=9~i^{ldIl6$mf<~6A;ee;V%AZ&B()nej^ijysJMEY(X{bY$r=Lkdk zES9}k30rNLQ|#JA9#M{CE%OY?7~gG|%g)X|@M@{NZ>WA*xj|Pq@cdiG_0-MoQdF*L-46P1huJk zF8wdFp6*`HtSApaUXG71wzRjam*zz>*Q~$qEBCsp*amDozrJU$`1LTLUPfP44__v4 z?R(xrC11?c*F6_cyd5<$HyH?6VO+aL3_E9IW5MUnS54*fy?DdG=rcV9&4%n8gXmpT z{(Nd)|Nnv{{H{#~tSu@38omWPhe7r!uek<`uNfg+_YAXJT+uW8&t-CBVaI|x5&ant zL$>~WmEQN~b0-@&_ruID&a;)XLY1&dWeO7^XCbK~G*x2`KI5e_m1@TCFUDFgfe=s*UH}-+Zh#Pwr%Rx);^2Yf9 zKcqLatdI3bCg<-iPOjCQ-#5a9I0_YQfO91)^Q<^Z-9cdix>&88+vlBv-Cv54Hg4In z1!wJ;zP|gyTe4r@!}a76`R)YmeBs87@pS&MtWU?ZKeLW{Y2|zzeE&^mj&ZKNvoj~h0~?mSufh%;G4qpQ$o3idOm zTp#sD!7LEaJBc|`tSud!8sPIfa`>k4v&fP#QjKM-Wp?$<3_UEx#9ynSp(^$-(Oc{( z>%DQ~y&^3tkai&JOOs3VWn*G!^dD!>c;R{}S=qo)mqUGLs0uNXw%{cGdnP)B(Pyeb zb$>sPQtlV$f|rHW5Kh512}Z*&GX$FrzHj@568639=N&J_$+WjGr>}ieb!`wUL7~Wd zwW_GEJWc1yDI+QWwtASK;Ojo6udqv0Ol`cfvT`ao7!}ZORH+Z>nwY5m{!3AHIr-H< zm{8i?lCuwbI<-99Z@v1H^9reE>SLb&ZQ*dQKi?jDFHhH*oHah@=f^qZt-QK0l#-k{ zFq^)nTroL2h)7(Syb^&-b|V+t*L7^-i{S_B9`GqqX<->Er3rky|v8 zL#f-MXlgf&i+7RTN<%+=G6C}}@6!L*dN?3KwXuBvh(XEHln}Y_C#lwBK4)s#xcsJ$ z?Br5DT6)$-wF^b#zU+6PCj5kDo^z-Py}jnep;v8L3>;f%`Q6C4pBx8MhBOZ(vC9-3 zFjpwhDNk(u)iC(h#VJc8Nx?Y|D|0HHcafF#$-%+0`9y}wH~#0+r8tMqc$cPpvv>uL zD7xGuBYwz`uW4F2u`P}^#-m-w|LU7(dwlBch?}F(pmCq^V2^%to0PJ0q+xifO>Pz~ z7s%X|v%TmQj^8hzy;&?9lys>rw1VP_rdbJPed}|fZ?0_;&O*zQ5ohV;#n$Xqm?ZWj zp-`;RCRm!@ipA{JTbfpqF|9F9lP~K_eV2HHG*AoS64eper~bE_YxD%LZ@B#AF3l}Y zEJ`)A%7q<2f-Upk0+Oj$RV|PAt(d9&%GO6MdG0bz(GhWewc<$}{Li_peSbPih!<&J z(ruTk;PIUW+wKP{ny*AlT=}LO7p{@!HMni{_rf8NUdmZ|D5k&3x22?Jpkf;?DjIQZ%v)-u5SFbYz0`Ip7o0nk3{p9avp z9((iq{@haK)jhd$uL@$9F<`!WSBh#t+OCqmrp}7r2U6UZK|5{2!TG1-Sv%79uV4AM zsC3Pp!UCidd0G70wX9^`aJN(Y{uXa+BzEk8uQ_+_uk~W~c>=WCRY`OMN5($$2A6+* zJ@DGKegEIO!$ZoH>jlx}{eO*e+FRNeNhke^^X#5+uC1$^R%Xm%F^ywhJ~6bFgY0R> zSr>Rd)G$0|Q)WJff zEe-ookdJZx+L$C(V@YnF)oza)w@%D7(Ql>k$okz>;FNc{S`aPjem`5l-j;tNQr2U= z3;YDcEh8^a92q6@l(JsRJc;jyTzKleA{#q968U@y`j=Kdt%c=L6|IUB{hw^pt-bBT z`WB-4`W-BmIJWNO?5_;kjv6W{Eq%Qs$)@0)zJ-6{8=W9xq}6w_Ji+~9#XDGuiA5Gz zCeoa8M5N~HSHURF8%PA0=|WlNRQCE8^d}0iYZFn^FvDS>lMy%gA^RkOaZ3??bzHs- zee<8Xy84GxFH2wk#ym7c6fnG|Zxa(EQ3bZ%-?9>(kEZ!9U~o_mirc%j9?56PKVIhS9?4x<;z0jELxq-27LM2os-=E>) z8i>xc4);!Pq*cxZ>8;MZ)AgI56nFi0AywAhuP2mLdN%qH?>S`+HjcIrHw*Wg`t{Y# zU+G2T8fzUbd%(*-*eG0|W7I2xuTiwoN9RTAv~!`ZrqD7vFB*P-f30!|*T9%AOH!KCNiZ zH;fx`iv0c4BpFI4s<+|ypwlWVtH%ozI-YWvijBs@Xxx_%u6^xunHw{JA*rd!ZKVEh zzrN9jc`qv+^2#-});qQR33#`-YU6mSVh#G_q6>eIbK)qcq^5l>@gFY<9l~HeJB~-R z(oY@+bw!-(S+>3Gy!7gkQa!WZ^oiAJLjj8k%OgWEv){8%Do^#_P+p#@0t7t{RsH45 zV{E~Q2hSv_aN*xf8y@}3k2Y8?_rUE8`Yglssk>h(H~90rM0xFP+4Rvpm%p;S_%_e7 z%i83EeTj5ZW1OcFUjvTFrE;M#h#Ea&bRot zxpHR4QS3`h%*_Q!>VN*|EL?j~(xbn2j-6;`oZZ&RfC&lWz6y|k=S%QN(AK+vb=sS} z$H^$ZGrMyf4Vz!aVY~_OAcOLn4tgQ(EzY)u-SPTzb)HSrF)4hF(rvODB1fpLj&kot z-0X63e$MI>M2*ViF6tJ8%H!@$=q6feyMlR@oV=}ruqj$)=@XXR@M<%o`Vh-Ua3tBR z#)uny-~;W!xDA>TU`@nlG?$WQ>DdQXR_?p9SU@>Sq?b>sT<3Xh(qL0m-`2)l(&M(> zK51rUG9Z1ogNB*Mmf`PDY7Awy1hin8j->BLrPo>Obp%6--OUiE{_-!~zwN z7>pd+ovqP)F7w<~rygyOL&wDu%&&djkbcPfYGtuBEti3*tk)v{;P4r#9~9e+k4Has z*~MD#93A^}6`MPf^yG4q3u#W@i#ULvdOW+G?)armTyOce**Da(8IKwWmYefErUatk#nUiiqd zQ!C$?O6_u@?XP_MuVB25jP(nnf_HO?G7Luh=#E^qWmr_ZCLI13TIGJ1lHrr%w#aqq02a8AEcJw{kZ7ExJO|J)qvW$s&g~Y z^F`F;(n3WuCJhTaE(wnurLphduY2~Tyw=6+>TA=k_v9aZa+E%FNH5C}o#Z`9{@rl6 z{H4_?;ntL2n*U~bS=nLS!7EKmKO@8@^UXk}Rx6Eiv^!|vBY=wuWRrWKh!!;~BLiZOC_!3D4@BW`DmNM$%eVT+z8-lZGcywfUAYa-Yzel5VD?s-!x7;*WmyO8x>%7zW2G=8TD_m_Iqt~N(mc~u#8ra(+I4K8ur z&fxv?X9)~o!0_0gF@_iaebLG8Jo)VX0H+yuCEiH0>Y6g#in6n3M!$)$5Z|X7UF5D{ zjv*0hV7Xz=M?1M>WO!#!`Zv~vwys0eqd|SVVt3lcC829K4MfG5T0W?sRw^P(ud_hVvEo``$mOOx;_;qTa%FfE`=Omnw*PW(QotVSg*Sc6JNlM-=bslp4;}U9RP|5EQ~u2c$FmS+;TolB zDKPd(+*4C(AQ3%l{V#(+a-s(z}SD(~BRFf*C&m7EKdKR`# z%t*YP8;oG_@$vee{m|=Ao$7dtrT|}dE6)p`QpU@$kcV7*<$cG|xfebOHLWh)faY;f&#qlEANTO}p0B$&d zYxdX2GbUIU(hzf~c6gZIOf^AJB=6;nOxo&njDpf3+%gtQqB%TyPZSpb7jC;5?{$sf zhhP>LEM9qhR}>fHreSDM@8!T3(i3Vt)Z*3?5Abw%4e14|ODn?2{K^y#sO!^{2-{S9*#Ua&It3i1i zKfe?>60u;PRQYf8($5z$2m8Ek5J9#(Eg&s6mW-}O2VboP5ol0tcDb*y6uQMi_p6at zt1Eq0sa5mJM7v5fUie`T6-JNVq{}@(bMQ}1D`O--#pR@S#Ltuyatst@DT9HK&}j<9)#HFBDKh5N=F4wi1Gw);`;mz;*c13FKG zf09H3zsY~;zIOedi!a~Y-k~U z#vEOn22#`=qB=N; z27Y~@%Bc#BPJ!k8Ao!1VHsXRYso-+KjYsT4-8M9dR0E3*(4xRu|==hY#HLw=}3P+F@t_h~kliabtP#Vr-im@kLW?VXYggzXBFo9ua<8;fLWG5V99 zoh<@WOC8|$ty{PLR|k;`(Q{2MH%+=AK|mS#CU%=hLg(2mbF*IM#YE%(S?ysR)X+Q7{ef2}#9&qSHSLv^ru5E}j{81>YM-b4b z_JLKZHb0>=wMj3dZYyW54altq+mtf!`r4+*sAvl1(#qM=ycqn9 zWuE>Ul0Pt8Am5wd9!-c$*rBMM)K-+rrz^8Q7F(>_7TEr?! zY@k7F>?RX!fF@$U1M-67l<*)pa)xLSR=)qZWcTfm!rJQ@g4j|^AK7Srs z6c4Q`mQU-yQ~Q80@1&*KczVX$6ok1)qa6J#9pzF4q`7c_U>VncKe7#x^R29`eh7`; zO*K~Zv5X1%$v&)`&TV=3V1M>*)`i}av!}*ImYUb`ydoGgAdVI!n zt6d|D;vo{TswV98nt26@oXy0rh9{5B_U-YOqM$*B7KRlia zM!vnZySw4T2bSA9o3mIDKWJ}YfIWsI$f@FY=iNJPKUJRHOQL3`1B;{PgHfotA1_RA zr#_bsxERgQ^mHSlS$zRAx^ zFd$Y+xd$KF?(Af|^FF=`_o4Xq)Sio-f>c{ZATZo*g z&klL9{M!szT+;@zY9aatl7kX-iNrg!BWLTb|k+oU4`Z8a^83+RBj zSdbUr+MCPto-knQ9sEl7oqh8Fm3Yi;V1^CDaWM}lQ7ClKB>nnqk&tol74d{l2)h(W z(!9pnZ!DKsBo96rvhGdk9$wP77_hbNJZjjmx{JDv@={Mk15b*8D(Y15gaFS_d6!g7 z;_;}#r~t0cEGkpf@QWax-xJ3EQ$_SW_>6Ie;2;DA1(BAbg~Q*D&f=-#$V*DXGhpoS zO*o;!F4sVZv{7&EFk@XbH-+R!#3`8JT%+yefv(m};#L-$!Pj)4k?!_%Hz30i9N_+j zhD%6SJGm9#BNN?Fw+=5a_o`5fd)j%Ee*mcxJtZ`3vn2;0MR5M${O~4_T#*cq9qQIpA4L3NffxN)E3GXMriOKud`@k`T@s zo1D}VsWCsPLsHvB5!N=g$iWNWwQCpFrMe9aYA9!x4n^NmUg*Dp1O0HyFXoBGurF8b z?BPJh%BQ+iIx801{!N|Q45*2UJmLkNJCSRt)jTrSthui$F zfle2wTeKuEv1RkrK7)O?y(I8i6&353*xA?!g1MqX1-bLKP7sEpndpukJLV!&Kgz(^ zd+6?=QdukT;nCo0s`0cnQGDpbS@6{o@QB z9}*;7DAHta6v6$4?A$w8j$p|$%rMNJa;9#}a=W%`F>@|n_gH%B10b9WMW{PHC|x}s z^Izf`;Nca2+s0y`R&nCopZDw>QCkkxaQ$5Bxxz9dm6yKCerC6?y#Eij@)2{?1!(yI z!eA;t2c(UXHORGWzo8cz6}(xTl}S-LsHM``5L*?Z09y(kFo^MMn|6VLQ3viPYbccY z8;FN{4aaJ+ad22-p7gBvVE-EtbU|#7&}jOK9uvp$v}Kk>HHON%CWq0E#q_n9GmEY6+dm|;`(`uk`T5G>YTuG=$a9ZJ zZ=0K*%zWWC8?2KMceBn9bMIjpd^=Sa;B`GnHk-OE=ITb*%$p7 zalDBhS>joTo0Ds-?ium+|2kVW-R-{rbvt8&_*rG$A|nCP#%L~u`nO{w-==F-;FZ46 zamoWGnPb1t2ucb9k(o{*cuU>X3TN}7rHvJ%1Dp&y7-f`|k1^4~SdwgQoP1tckL}OG zHC~1twP%C{uv-|I?bR#pzWHx|hFuBPMXDA&pKtcZ3;9?O%c21l^It*sMjOq7*p>_T z!9Th`Q7YLpm*TXQZe0llQQQNl5mzVi#v<%Ew+pFPMj0>weM^{ zJoe|WjTY{sVAIa?QhOsqV1F7%$B+gC8V<4-tm`JoMsMzw=(5sg0A-7j4^N>Qu$ zcc|%wYEXZxvuRr~U%^gWtWq%y&lsSu;`=*}l_|nq?9U%vhMivs8h(UwJNx9B*PU3%!X(OUwqMz*jr%Qu!otq=h=nhRSCv`wness*|G7>CF7{Bhk za?qrMvc+tSr86sjif98`74m>hhv}Txk2hqMfX=@bQ_h#iyUZ9%SlzxO=01C%Vt%OM zn8i`orfJu~luQ(Rq7@_mzSWTgf(bPkwhkj1UTx8)>qReXrr%LWJmCS9(2ZHI*@8yx zl`V!AImo?4j%#UQ>i#(H0cZp;4>$<}3QS-+B9)T&9RjlKb#C&rS)uXz0^kSd08TeS z7$WICgnwZ|x%uCS{e?7k`wQ=wb&~+9`(IDL2v`XPr1EY5 z)^JhR!dsD|?~clZ;4Z_zwnjgRsejr46M_AVhDMX(vk#WJnd4tX$kfAecMEy23TYCC zJ{i);xwB3vibr@eW#dNLe%R;e z$i0-%sbbLv)EWMDoPouSSg=S~c;U0d^F_gll=@L9+GuQMQp4!C{)`WB5M$w}>=3I# zakkpYf)_c5-*3f$WDA2lT9ZbbTe#^B#XpzC7vvsYqVTlo8mRPv1%C2jCZ-b(elP33*HXct?eh2!MP`qF}19t^zgZl{ZXB2J_6%GORx$InAn$)iC0A;GG`bcsm zef~=LhE@!nCv|vL*etHix&Uz4zEKFt9M6>gv4PA)j$@8Ak}vCxn9>iN$0BJTpCq@^ z_vnw2q}3rfoe;hYmXY;OcrRDFO}E>C&R%lw#~GhwqwecNR$2~vp!$jPxY7di31~7T zCc?gjPXswsj^2qSt=W__-4VxOGW(O`O#S{mmmghH!NI{@6w2K1-)*M26J%|5l6?>N zDERriNKRQSO4{}sD(Q7>dY!AYSJLGPXWy3-IUnyRT#oKE_l-KsNi0o=)ZG2?!T~7Z zn8?EvMjI~{m#_x4{2B;@z2JYclP2|q&H#j$lg}PoTu%7^UI5Xmb=i`|iUGT-snoGD z1>r0vvM09k!!twRR|J;Q&*wL=+MiPCOCAv0xKSH~)mRIRHmMY{?+2s$X3m*@dP zBpI*Fc0K@IM#ZR(wrlwoW-AsQnHU7*Vj zjB@U!R7OeDg#Y&2(!d*KRBL`gh?TkbOn$#XwUz3Knx6Ov;ek!y4)M#1aLmxTV4=98 zB4Lt@5oAzTS^1{#4nqr|8-6%m0TVn&1jvz(hAk+VcdvaCKDdquG26u*6x#A@O|^pt z^i#`L*bz#?bDz82FvkK1V>37dTtbG=%@;`t&tf+7)pa1;G4LoTuPx6WJARzl;6HeF zr$KnkK5b@HGs4(s67LFEBAz*#*B{XNlfn4I!2xXvaY^_9C~BRJ>OH1oe~fk7{>w z3~LKVjD5D4@J!~{o>GSYb@A!rB1cEZshI`|87ZkZ_+T`LUj3W=%fmvd8Q>@3zHjU9 zhV$o1xpl5JU^Os}`IU(SFe;Uf4{P5eD9I{(F{EsAofMwtB|_r)c;WB$$d9QfdbJ_K z2#)MDR2MB}oDBn)0W43ml9#SH+UF{u{{?=5WF7jnla|X0qb?i(QQ>Nhv0)p{l=41a zz&!~HAOI6!;4xrnCHyX6Afdn!mlimo=vZh_0VWam;$~&lK*Jb=&N9qC7dddFzAf_h z$G<^$!g+n_rs9RDK>ngj7SWM}hKw*N!SZmM9-OkrEP0-_tW4!TB#?M(fCFmalNA6dqnuVeKg!Hn{?>=8 zo~iTKMqj-eRcQD!Z`z$}c{;Xc@VL$gHOy$-bo=L1N0(vUJGw0!k8LGgKli6*F6Y}{ z?XTySHy=8@Wo(0B>ap5jTh4B6rPQ~r7aUv*V?UP`u(FyocF_+R^arC_nSryoi&hR~s4< z5}z9iNCv8C$c;>`T-@=@iYLr!{}Zi(PxoO}DHDG(?v@D@k8nU`IooNC=Jc#My2O^$ zJQ~!;1d-c1^3gZ&qm`T0MS|A}(*I|xqfkx9qpKl!5 z@|B0e&%DjK$R_ieA$_+i=?ku{$9;`&=(gZm?`GzR8eF%r6|In4X=F!|gqnk%;H?48 z+xvI;Pk)xZ7;u)C#E`LOl&w_Ty0wh$N5oK9`1ke+T`rn=qU z5g+6bY!09HN;xK26$NnwmncZd$pt%gBRbVC?~G_Md&8yfy2E~4EBf_uJ?w6Ru5@B{@P znjBMC%Fb|(0b{o=rXplR?c}}PmUEZ2T+H;!2i)z;nifVp9*sL)ziQgV=De?Y7M(Y2 z^I$x_UE-*7g#gg+!)^t>{OohDSWpAuK^rp~_p?T{e*9Qd#~ttTpHFX+Z@QT25jTE5GQ&I%59**L)-r$r#9A1& z7hi0e(+V z+c$ggli&8=CPpv=ow-2Rb92`*`XSZDTf@2=%7fdM8=z?+vc923&B@u`>9HsaUtn2T zxU~uYE$yGOloM}DIh73i!}3@^mB?sN9+>17D=bdazw)z+wJ0xtjV6Le($NzHm}ce? zer8^ds2O`$@C>t0q$OKy`6qY^y+0K<0;0<&Am4eQ7lp zC9Y1F-li(prB>7FJxQ=OVc5CzUfiH2-V*@#w@XQgm0dA)Aoj}KjRSvTW28#@!xN%z z;FOjC3Ck`LCG7VRM zVYvKezF0~z$7>#}Qw;Z=H%aeL3wP^eed8#wIcY$2|KKz$i7-Kt&IB zMYu(wjuR9lyp}j`J;GKD$i1kC?o<6o{`mNAbMlY3j(zvfbKJ088b9idLuhScm%GRh z;DlT~v@vpeL)C;psBu^9k-@~g!3WXU{7{=WbRe(g?9zephP=U|2X7X7_F2lVy?5br z?EZ?$O1P1mXP=60&pkl+8S{^hHCZG4Ko??Yf!G!T$HDU_5uq+Jzvky5zr^FemWwtJ zim%oBv*RJHyC-2Zs2*}vJD6@54j%V=)RxKeH5I&VW6|2EXQC1KcW`cE1<_aBhe8d^ z;jB9kKR_tyGDUa0Qt+U#z_G>;-a{+&+^MEkoxl0}R6c9)j=QX_Ds!h=V1aQ#Vi;k% zIVO0+Fx-J14RWLu%$st_BjBE(5uNQEi9kSsBr(ip`Q*sjUA*l}A|}NU?b)YVXtx?h zj%FE#lFr!Ye*6Aijr#m#7@p91%f*LJcg-{Nw4`aZbUCZm`!MG}J2e^**+=_}A^Emc zuu)D>2S>xRh5I}t!jEd0jm{m<=#rw|Sd%TD5unZY@0OFj1dGE&XO~-=DB3_N^fr#K z$wg>l2wUjZySs6eOAghRQh0g!g$((g>ik$|h<P-5 z1LB4js{&CU4;mP4kgVR`cO;wba}&kV%I=v-7^&FF%7nF({`ys&EJ9k+0v8{{t$IA; z#A{bhwaZ&k!ZfH)osy$@NJKIYB^|6nB8l?3@h0O)VMm}d*dR0xwQTBW4|GK2k_Zof zD-Ay~qr0lu$+5eZ?Z)I1(IHicc6zXLa#j~R5tm+}Lj+yfRjen=k#$12g?M_1PcneX zdLqDcFv6(<^GGJ)8D%z9_RY@xYf2?IAAZ! zAuQ_H4fha2*DEaqOkOA{-r6ANBhivz1PV9*dPYkV);%c7M2sWB2mahiQNw2_ z$&0ZQt&NT)Vh;*WOC!pqx^6Gkw!(u zABYqLk0bmeiojfeEFh!$<#(oyPU8be!504F%L6OR-i$BBpN_>bd+rqU8tzp_*wsgf zeKtSL#3mVRnhQh4Ow>W+)Z(``w+JUDAr}C-KGaW#;?<7N`oeSK-U(rRBv^0Jm?QIz zeg95jjo_s?64##L?*h)_+kY{0?0#S@YADKDT2B{T6QqG%D~ZS49!l3{nyH3#rqHp} z7JfV7$#u|`X~Xree_!`xx1u@PP_B=cVeFJftDL_AkV137Aw**p`13ex#*3Sw$Wp}q zPJFe@hYz=s&u0oSZ-XAvG9f_WKdFsBMX}Ohe~xa7ihJX=>wrFY2p z_rJ#7GJG>Wp>}L=Pcl4!t%nM!7(ECculBg=Gni)sAE5W3UWlX zoi|}c?eWGX9n?8f(!mXbPh`SQUq>c-pydyY_DI75Jq zKuj$Q(j3qf;!F=eiZ8mFrFu?g+s3NWuzjO~kNjNZj?3O#{BrTO{BM_QyVqRPg0fgE zERwSX)AM$+Q9cPGFTIVT8-D+fl`y)NbDrShu6JL zA3f9(drS~yp#VpeWn>0ghXV&{aHRJZ@2~FJm(*D2<`ZU9p~=5OqNo-8=8gLPV!=Pv z^c`LBg(4kq7-dA`kIHcbcbiW+p<~qh>$iynOhI=PQB-t?0Y7XY*wZHr;PGm^n-$oQ5J5_ z$^9y$)JLT=+?H(FR8!1?q>)(E?S!rsS-M+pk3E=6FhM7Bjff5t=;gEGpFe-lLg-`> zl3cW%Y`9@~4$=fi6!f6II-BielOrnKd_rxanH&9fw33rPUj9#_JhU@uv!Aob1}Bs1 zA8eY;L}P}hfn-dHh27A_YHA{{xNy(-`yOh@wz>oR2W!lS0x*-G)|*00VgmKO&nI;9w|e45+<6E^&{vAh7J@2x|pdc$!RZ6GH;@sFds(0xV4;4m$#qL)trX5CS7CQr`w&JXHBy~5=Dz7gpXjW-RJLK#2HPQB| zXoM-?y<#e)*sh}}XZvm=(bS?UCx?Xot0U-*Y09Gy3>{_3Z#>LI8wQULEe6+&u%&RZ1fq^LNW6+PqBjV?1v&Pq)1JPS zrpsPKjR&#R_+X+$f-7gp))>x# zJ)c}%Lc(+8-^F&}%zfyIIV+{wvR9%kSxFLSmE?~i(B$kxtpC*dYmrMmstE~|~NpC+2b z*ZiL7UO&{961K+BA`a8%q$O1f84l3*uWpKv<+6i6U+xmYPss9Am-Hp2clH;|1% z=3yoe&;L4jXD(&8KwoJ4@U1MXV#Qbv!9jLYxW$&BdiP{q3 zjb7l{^N!JP-)#YgVB~&~f%Rny`Uag)BY;C?ntxz>TEj z>r`RM;E#{$E_@uCaopQ&=v9&NaYm{KvlRbpx!>9pAhatOtQa8fg55-iKyy$tO$hA= zn>gg6CB4DlA^zj1we94DzPDcgkGD4u$8zu9ho4<46>&#JRH8B@LK!k`GHjAr#taF` zJkONO8FpnTiLfPPEK@}0q9}GKWlT4jr*5}~C5Vb%)V~l63`#VIM16 z>?{lx-=8$%CpF}z{z*k|A2hWR2FiWYeqR_x9{S@ojPI#ez}x@I3#wH>;!ORkP&&X6 zg7cai7KDxXk(HTz1x1tC=V^DS*Py9jC!K3-YQ&Ld4On%WtlseFyQu1nOcS5lMS*HR z@%-vv2O)Jj0VdV}(Ol$^C{gN%sw0ALqo?|pg|-zV2YwwA2SzR|6aa$l2N=M#*66lH*4FU2aa7 z6ZjDiA)xqXFLXxqFTMnh7sc?5LyqZkj0T(qN%pVlmmR`IuRT(bb9n^_w|QlyRFIr* zdO;!bMy=c2M1X2CWI;nT2si2Loo>V2pJ}1#DapdI9!K78Nn4H zGcSs&WW4i80qw5N`zCsiGc!YBsB`kGn%~~zBqmFvCm5>G(E$!SfKX-0rv8a|0JfVa zPL^1kYiC3QCRq!w#k!uTLpG48KFZ0tExnAnBHujvhJ(o|nrtdq zAxK}#?ofMm4SR8AMRD^I#IoLIe_;V~5b{lmU)58TF}*TwVyaV^g?>Nd z_>UF~ksvuPhbZ?G|(DE8v>$qnCMGDA1)_~nbaFUO9LL-3b!DHgC{8ZxLK(4bMZBK$Ny*n z7S5T(POYH-0W9v$Z-;!_(m!8A9`ZJd>NcZzcGnfJWX1H4kJ0Zyp2-}s0DxwsK#(k& zPo#k<8u`UQ+T^XS*%VUS>4WZUN#NJw-H%)1$|%!73g{~l!+@p4)Mj{nNPO7{aViR| zkX;K?&$)!GFti|mSn(E4&<6|_G7&u{QqwCc9uj^VvmVGx|~n>jv*T!RcF zzUKf%MqTo9Wuy{2eC`I=_+o=oL;=)Q!A%m)xtyl)?-nuu-Fp{+W`XOJ~S)e@nphttHu z64zv>-Vz_5;6?ea1O*PUHSCYo2H!sL`IV0d3QLdf4M)(5bWc-zqJ#h3L)ct#hwAqw zH8MnR0L1hhcmDdI%TuVAH9cmsk(glO9gZrmJ**OMC{+|m%>Mlox41XT8GSp9eMgV0 zR?h8F<_31VV1kmhtvi^yOAwx_(o#+%80J2bMk@k@bX>1E5%>eaydwyWkSI+*- zS)EO&{ysb0LMTO7e^IIwv$WB4$I>j)4EDCP*ZZ~+pCYs_1XEiDMv0ix#@clBk!pJJ z4~1}Q5iLABkU8;QkzxX}Lo?CU{vFb$E8Xd`vCgqSQv4nA43A(x;>UOYS8n)*Yl&^tgr;i%9u`fJ^@f23&I&sfOYQ zCX^jD+tI%}%{Z|_z>HRuXos!LEl1Tyu@-)a01bTc(dn((#XJT!v6`;<9w00tJ&0rq zE=BPpz7?+j+L>v;BP~TEkoI3Mj_5p?!Pv-zRCO{rHCC2eo}LOU+2)=>iEvvR`q1qS zr~h(}SJv>-vAt#xm6)vk)TN=LWeAtUkzoNam!UW95oWJdfNMpY&AIB;m4G&=5I|=G zCa!;1Tc>Jr+Dv93$77Z372*)E(sT8>zFg48Xy3XaLeu@Xo#HI?ZF@?hq}PX}Em72k zWF~TNaPv3Im03;Y8*;SeluG{Py5s+G%=lD_vLSN@%SKt&C( zX5JWHFH!zPNO9qR38VDw+j|^iG=Tzf_nzrI-c_9wt9=mJ3lG|Hz4$kcOL{4etTLe$ zM*3F;j{o6%c6K9vLfW&L(|BKiXsvdxO-M}aZCCZW8*YVw|1cM<5{@^tc^WLSCP1a{ z5?VYbgi8(RsZaw-xJr@Vtx1B1MB&vC*UP4y!9aILUeQR8f_#AL4pAjRbOY3n_r7`veK8@8 zgU$1miqVX~r%(x}459Gy2ZIjVvqb(Ef@kD^6;Us2oDZEW;2*XQ6lCyAzEWz(_Ch@a zk z5&~>S5pUjJ0*io6Cz8IJ-Gu()R0bnLAz(+c7c5a{qFO}56(k%!03MN%>;pDOh6foN z@YP7jqtpTkI%BLK;XMdC{q0qHq~b#VI)-i%S3$8mm#ctMcVf-cMasmU$eI&r#B_K) z3+wQ#mV}Q69rmS&I0(WOUI+X%&S@;jj@x!UgiXNSVTU9FdlGk z+(egKc{ajka~h;BAimfvs6+6Czk-9^B&Vl(qsCrBNkS;}>xy^@!UtXXn9MWa%QRu93LEO%Oiu7Bl+9^*|py zyl8U~+Jp1Zs)fn1kM~ulAPR&DbEVLefPkTZyt-+YMPyGRlh;tfYaaqd#B?2+zjYb= z#X%MGJYa*uD(;_zc!)O_kd(Z!*daYUKiUC5w^?F3zUTz<63NWUrAC&2I;^4kLfkiu z6zX>bPD4PfLqM+?MP&%f22#NtK=nh|PBv4lblDUNZs+O@}>jNYv;8k%Gl9Uc5F2plGekefRA#9M0~N_fZi|Lz{vkV}i_; zLtjt(ps|-Uw6yqU0L;lNJ;H#Ipaj7tDRAZfmDvGg$&7ObPzC-*5PE;!!+_+Ai=u=Q zgs_G^r7^HzGbk+=fQcShnM9Vu2~jZ7h*4s*qzE9P)8?%IV%?Eh6mS;UQ0$j49N)kH zz|vcjwSCccTE0J+L3vg$Ht;X5RIiA;M@JV0Z1}_260=U7j1pi*`4WbTyNrhvrI$%a z-;IB(NQmB;YLX^86@T^ESi{<=VvGXudEj1i@(34nf?dV|M73iH?VfgU?+OueSS)BL zSmNGZMVt=;70g?(Fz4+L@tnls0yGePPV+*;=)Xun#$y(V^fHuW&{Mp6(FvgY-w#N| z5WAke_C5T?$PuQ;V91EpW~`!~e}gYV3E*ED9jub>k@;v*mORyQP1tKGBLT1p7F=qv ze=DH57g{+i{?byr16H2kxrST#=M2>(i1hti%jbZebJZJ78*iF2Rh>4r(me)oT~`+) zQH#E)FkJ6i-#Jc>>l016P(h235}hVcyuL)VvLFev8A>&GDht>kw`hg}8@M6cMG*N{pJimDfLGtHo zfI<5E;ogXbCpZ|J#fU%9V(g>h64A95zyrB#1XkcV5JW=83pfdHEHM-1fZw2VMjs?} zZ6SOv>O<*z1CC^z9VkaZRvTFnqr{}|D}5VMNW4P_1IvU^2mCZ#=xHIL^MKTFWq^LloAtT*{tGAZ z`}ByEV9s!gv##C+D1)q*scs$JR#-!G5SAhwgtD_UaqAAc*@?{LL88Ax7fhex5&t*0 z6r-ne9sG7TIdxw{u!$TnAYO^xoIX^bSFQxY!$SnIxsz6jos=3&P{>5OJ6_ggMVk5s{Pm8mX(i#>B%{Xx|CDc z%7+@6V4)y#IC1AM=wOkF59aK!zTjIzV{Yo`L7DB|||* zG|cRBgQ67&Bv>}}!;dG_!Rx`DiC{!WjrB{mYE)AJo_bNL(nbXc88H5H_xK3~J{gO)-*e~y^RjHqjD3^9jX(B{dq$H_w6 zNM!vm(Ss*Wepj$Wio6`P9m*0QHC5L)V1K0g+@^~UhlWVjA}?sSbt}{%hK8FL!4z@0 zS!U3Xcy?4JKzWH~fOyCA^JhSgL2c4bG*C!NsxRV2N`X4k?B}dS$o3s?|LHLLBz^i% zsT6XqNZ(b6+{V8Y-)5MqtmF5e*-Zpf$QlT2k2C|z4O#o0_g6h7;Vq(gB*EA_yf^tUpHbx-I{)ddM3=A8NgU<$xIsV~ObWR7{wj6k0GyaBOeO&1 znN5{76bFd0K+x~`?@IV%B{&fj0$k$JH?gc5@BZ_0)ZY*c;Q1PvHtkC$QpxzGNC6^6 zPyfXLJ{+6+{%h0Ea90ixLVUV@lmHA0*kUci1-1{X7w4oEZ`7n7#a^#aP((E4icmea zbNt(LP$dYpWKK5p`mMbA;S7ZoVZ7(&I{=f`SEVt zu_No#p{ouX1Jd+RTmv|PBuTxLyEjT{(C@uoLKjtod6`9h@iF2nmBP$et@;uo0fXeSqI2 zIBG&a1ZEAfIu0_5sMsE8#D1PQu2ZJMa_HJ z+QXkJTQ~krym~kB4THG5t^VF(O?K|Qy$3YD?);lAEO=zQw~2jUk6!}Wt942KfKKie z-iRRT`=;itO92BTT-aq2)eJrlWrTWp?3vYSDP5+j>2HcANPYNVrj z0orj`YyXAX-Q&H*w-LC~Q%Rz32P`Ex?Q$ek(Sy*`&$(3q&C!ts?ym6Q2b`vop{E+V zeU#dt4noB9nH>YLk7%b~Ahl1v1`So@uMz@gHa+uA_6@3iTuVbIZ~^tNGw7^s_6&Vn z0@y-UDpAO%%o z-_wXvc9{Zn?g1^**cink1`@hetT%^i7djAv6K5-%N4XOE(V1CT1XF&xSKxR7j(!#t zRvvE?0;NnAJRLHZ-#$;oF1==>rC*`Mo{^zV%xJ|LTPGFzK zP|(lliEabh$N^u^DW_Iod4rb3-{|c(!9g^j4>VmPt-5QFm8IE-VyeuIXOy8Q zQIVB&FkM5UZL^SW)V;!U3Qj+an#|!KtS{vp)L^o4u*;rdmCrEiw0qyHr<5dqos5oA zHg*&OqCP!G9?2Dh3-n2tra=@Lqdw1jRzgt@eFEm@yWggEq&Oqvt{FtlP zs10+~pFR5^CcZP77XH(eOKH-j;M5v;JEK-L4nFC42Fa0+bK;vqSVG(9<9&tz13p|B{> zrg++`mGh3>OeYd1i(@~8+6&OVX6by ziSE3p5nj@qa(c8U@008+^1au`b{5;@nSIa8*DSZBYe9#_tc?ZfwBR94#|hz|lFdst zr9HpX>A)Xofk8|q0C-foyZP4qZc_)&9b>Q8c!ypp)2+C;91wD}xm=K%1ZnW*A0g5{ zC&kyln|!GD;Kx!8-)nl{KQ8d&h)>`T@u|nHg@>61<|$q3IxoNR;YJZaq-TTrb(DHm z97fGwy(&l;2AuC_#4y2y>=#}_=P6&`Pm5H`Ser}pO$9Q&E;J6KCTuR&5~IeUF7TY% ziKE*fLDzFbyxS^J_%J`BfeOyQAdsVOP1t0~1ww$NHF@Hg zSXqhKz4JIpL2K8yRp9J`aBX=#2bx4B*S)WXIdY8WZPYR#O72-j8tuS_4584w4D3wx9xmsZ}W$X zB4&g47n%(&46wE=oI}quhh7y%d8(SFy(FMwqH}6gmx-07cj7T6?AC?mV>?--{21ye zz7Lv{PYM)TyejJ4+a!SX;624xlv{!E&UrJK5+$&pn%j$&Nx2g0kgC z3fO`|ra^WuLhy<~UJ|5qLsEDDH>V9E(!YQkbf|6;;|7VrZ1+ zG;i1bs7Hyo3*@H~qqYw#2g3!R6D3S@nXepGjUuK{HyPaCyf6ZFbf`oe*U02uWS^i~ zimLGBPjUOS<6<7#l@uE}mTCRxoMU@*AqwCqt zwX3XH-w&mg@4&sYgoctxII18d@C7J^w1VNnDnqFvM{lIkX#ffk0H1Jf=xl^>Q&-U~ z+2&N9ql)T9xFQW5@0Sb=82qHI!m8CETV4k(?=FXN+8X5ZvFC!VCC@vp2cR;{NE z7=iAwT9UxGsJw$Gl~lTm^d)Es!cQmUhq0CYM}x7@qGf+x+2Ag@Ac_!rec=_@#M_+R zlgSt*rJP9yZA z{cKYZjuCJPP^^8_Rb2;s2gj2K618b_=D%COWneP3~JtapQ3wlM#z+K2(?46R7aTH*buK^uQFpQU-_H-E? zHN4+csvEX_MXAI-WZ(~@gCEV6xo4h`&XgGO)H;MYRsnkxt-?@!hdbz>y*)K2_di+y z1`^c)QxN=9lAQ)pZ_}I~)UY_1B4M_BS=erHTSwR=I=>LAhcE>`p zsIv&kaCj4{ng*OuoUik8dTJ30_cE-KEr#ozPKUTeraJTpZ)Hx}2JFw6j1VEo}Xv{jozmDofcXM?pC) zQ8vO1^&31Yp6$?JgkkwV2L=Obu{Ag!oKv)Nk1t32?eUvCx(ghRtgP1su;p}R+4iYg z4=KbWt-T!1`R3t8bqh)K1U3hD=i9E+-~-k*((IKwnd=~J?}cZ_O$^vg4AP$R-$PU2 z1&cFn`uv#7Cl8;v`LZv-GTivxGmg;p5Y}5*x^2`UfJI5Gq}Na6R+mYP-t8%O>#BwQ zLmSg{Dw3wgw}JgTIgMB;bJ6Psv<{%=?R-CPFJ8+TJ{| zQYY)FVMLdnT`~AL*oXh~)hHRqq)Fdn?7l`u@fsi%RsF{dd7%dzek3k1Eck7d`=CQr zL;F~M2go~ClGM(iIZgrxX78msaGNcRI$@j6Z1A@D1N-&zH-T#Z>^@?@z_95wFx4&X zwJAi;uK;ObrNy$`BnhRlasBqxqbl6T4fWVe>_6PI?S9R9^Hf5(vY#mp8KdYSX_std z!m%s3V}Wasj+V_U`}xTcjo~&oCb1c@NJn^>4_+D1s~G8fz9YrLcU(?Xk?IfaecDUM z1e9t+w(cmfZaz{Ah-#$5E}QsdHFa6o!E$UX-D%G{+NTt%>XXc@|5Uo2JP{#k(rNIl zc+;eCe(YnTmP$jXyk0cAWS4bx%HmN5B-@ zoWe1wgVV

  • +FmPxB8TQ|k(ILjy;46OzaR*+DDJGMt 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 literal 0 HcmV?d00001 diff --git a/src/openmp_c/2_Syntax.ipynb b/src/openmp_c/2_Syntax.ipynb new file mode 100644 index 0000000..3cbd08f --- /dev/null +++ b/src/openmp_c/2_Syntax.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a45c1d76-fbbb-4ae8-9224-3ede2cefce0c", + "metadata": {}, + "source": [ + "# Creating a Parallel Program with OpenMP\n", + "In this section, we will introduce the syntax of OpenMP, how to compile OpenMP programs, and give the readers an overall picture of OpenMP programs through two simple examples.\n", + "\n", + "## How to compile OpenMP programs?\n", + "\n", + "When compiling OpenMP programs, you need to use comiler flags to enable OpenMP, such as –openmp, -xopenmp, -fopenmp, -mp\n", + "\n", + "In this book, all our examples are compiled using LLVM/Clang on Ubuntu 20.04. LLVM/Clang has the advantages of fast compilation speed, less memory usage, and modular design.\n", + "To execute OpenMP code, you need to add -fopenmp when compiling. The full command to compile is \n", + "```js\n", + "clang -fopenmp filename.c -o filename.o\n", + "```\n", + "\n", + "It is also worth mentioning that when writing OpenMP programs, you need to include the header file.\n", + "\n", + "\n", + "## OpenMP Directives and Syntax\n", + "A series of directives and clauses in OpenMP identify code blocks as parallel regions. Programmers only need to insert these directives into the code, so OpenMP is defined as a kind of directive_based language.\n", + "In C/C++, the directive is based on the #pragma omp construct. In Fortran, instructions begin with ! $omp. This is a regular language pragma (in C/C++) or a regular comment (in Fortran) for Compilers. So special option is need when the compiler is required to generate OpenMP code. Otherwise the compiler won't recognize it and simply ignore it.\n", + "\n", + "The basic format of OpenMP directive in C/C++ is as follows:\n", + "```\n", + "#pragma omp directive-name [clause[ [,] clause]...]\n", + "```\n", + "In fortran, the directives take one of the forms:\n", + "\n", + "Fixed forms:\n", + "```\n", + "*$OMP directive-name [clause[ [,] clause]...]\n", + "C$OMP directive-name [clause[ [,] clause]...]\n", + "```\n", + "Free form (but works for fixed form too):\n", + "```\n", + "!$omp directive-name [clause[ [,] clause]...]\n", + "```\n", + "\n", + "Where '[]' means optional. A directive acts on the statement immediately following it or a block of statements enclosed by '{}'. Common diretcives are parallel, for, sections, single, atomic, barrier, simd, target, etc.\n", + "Clause is equivalent to the modification of directive, which can be used to specify additional information with the directive. The specific clause(s) that can be used, depends on the directive.\n", + "\n", + "In Fortran, OpenMP directives specify a paired end directive, where the directive-name of the paired end directives is:\n", + "\n", + "• If directive-name starts with begin, the end-directive-name replaces begin with end\n", + "\n", + "• otherwise it is end directive-name unless otherwise specified.\n", + "\n", + "## OpenMP Parallel Regions\n", + "\n", + "As we have mentioned in the previous section, parallel region is a block of code executed by all threads in a team simultaneously. A block is a logically connected group of program statements considered as a unit. Next, let's take a look at how code blocks are defined in C/C++ and fortran.\n", + "In C/C++, a block is a single statement or a group of statement between opening and closing curly braces. for example:\n", + "\n", + "```\n", + "#pragma omp parallel\n", + "{\n", + " id = omp_get_thread_num();\n", + " res[id] = lots_of_work(id);\n", + "}\n", + "```\n", + "The two statements between the curly braces are a logical unit where one statement cannot be executed without the other being executed. They form a code block.\n", + "\n", + "Another example:\n", + "```\n", + "#pragma omp parallel for\n", + "for(i=0;i\n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + " #pragma omp parallel\n", + " printf(\"%s\\n\", \"Hello World\");\n", + " \n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "10854180-9aed-44fb-bc31-7af8927e1675", + "metadata": {}, + "source": [ + "\"#pragma omp parallel\" indicates that the subsequent statement will be executed by multiple threads in parallel, and the number of threads is preset by the system (generally equal to the number of logical processors, for example, i5 4-core 8-thread CPU has 8 logical processors),\n", + "\n", + "If we want to specify the number of threads, we can add optional clauses to this directive, such as \"#pragma omp parallel num_threads(4)\" still means that the subsequent statement will be executed by multiple threads in parallel, but the number of threads is 4 ." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7ce78416-fe49-4d11-aa90-18defa433799", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + " #pragma omp parallel num_threads(4)\n", + " printf(\"%s\\n\", \"Hello World\");\n", + " \n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "3567be43-e4a6-4bb3-a0c0-1052593d313b", + "metadata": {}, + "source": [ + "Through these two simple examples, I believe the readers already understood the basic structure of an OpenMP program. Next, we will introduce the factors that affect the performance of the OpenMP program." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "file_extension": ".c", + "mimetype": "text/plain", + "name": "c" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/openmp_c/3_performance.ipynb b/src/openmp_c/3_performance.ipynb new file mode 100644 index 0000000..a56726f --- /dev/null +++ b/src/openmp_c/3_performance.ipynb @@ -0,0 +1,82 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4b8fad19-277a-435f-b590-615e0b18c764", + "metadata": {}, + "source": [ + "# Performance Analysis\n", + "For parallel programs, performance is the primary concern. \n", + "The relative ease of using OpenMP is a mixed blessing.\n", + "We can quickly write a correct OpenMP program, but without the desired level of performance.\n", + "Even though there are certain “best practices” to avoid common performance problems, extra work is needed to program with a large thread count.\n", + "In this section, we briefly introduce some factors that affect performance when programming, and some “best practices” to improve performance.\n", + "\n", + "## Factors Impacting Performance \n", + "\n", + "The OpenMP program includes serial regions and parallel regions, firstly, and the performance of the serial regions will affect the performance of the whole program. There are many optimization methods for serial programs, such as eliminating data dependencies, constant folding, copy propagation, removing dead code, etc. Although the compiler has made some optimization efforts for serial programs, in fact, for current compilers the effect of this optimization is minimal. A simpler and more effective method is to parallelize and vectorize the parts that can be parallelized or vectorized. For the purposes of this book, we won't go into too much detail about the optimization of the serial parts.\n", + "\n", + "The second factor is the proportion of the serial parts and the parallel parts. It is well understood that the more parts that can be parallelized in a program, the greater the room for program performance improvement.\n", + "Amdahl's law(or Amdahl's argument) gives the theoretical speedup in latency of the execution of a task at a fixed workload that can be expected of a system whose resources are improved. This formula is often applied to parallel processing systems.\n", + "For the speedup S describing the effect of parallel processing under a fixed load, Amdahl gave the following formula:\n", + "\n", + "$$ S=1/((1-a)+a/n) $$ \n", + "\n", + "where **a** is the proportion of the parallel computing part, and **n** is the number of parallel processing nodes. In this way, when **1-a=0**, (ie, no serial, only parallel), the maximum speedup ratio **s=n**; when **a=0** (ie, only serial, no parallelism), the minimum speedup ratio **s=1**; when **n→∞**, the limit acceleration ratio **s→1/(1-a)**, which is also the upper limit of the acceleration ratio. For example, 90% of the code of a program is parallel, but there is still 10% of the serial code, the maximum speedup that can be achieved even by an infinite number of processors in the system is still 9. This formula has been accepted by academia， and it can indicate that the maximum speedup that a program can achieve is limited by the serial portion of the program.\n", + "\n", + "Next, let's analyze what factors can affect performance in the parallel regions. To analyze this problem, we can consider where the overhead of parallelism is, and then reduce the overhead or balance the overhead and benefits to obtain ideal performance.\n", + "Common parallel overheads are mainly concentrated in two aspects. The first is the overhead of thread management. Thread management usually includes creating, resuming, managing, suspending, destroying and synchronizing. The management overhead of threads is often large compared to computation, especially synchronization. Multiple threads waiting for synchronization cause a lot of computing resources to be wasted. The idea to solve this problem is to distribute tasks as evenly as possible, making the thread load as evenly as possible.\n", + "\n", + "The second aspect is memory access, usually, memory is the main limiting factor in the performance of shared memory programs. Problems such as memory access conflicts will seriously affect the performance of the program. The access location of data is the key to the latency and bandwidth of memory access. The most commonly used method is to optimize data locality. We can improve this problem by explicitly managing the data which will be introduced in detail in the following chapters." + ] + }, + { + "cell_type": "markdown", + "id": "88d81637-a94d-4830-9ab1-2c110cf21d99", + "metadata": {}, + "source": [ + "## Ideas for Improving the performance\n", + "Based on the factors which affect the performance, there are several performance-enhancing efforts that can be considered:\n", + "- Thread load balancing\n", + "- Minimizing synchronization.\n", + "- Using more efficient directives. For example, using PARALLEL DO/FOR instead of worksharing DO/FOR directives in parallel regions.\n", + "- Expansion or merging of parallel regions\n", + "- Improving cache hit rate\n", + "- Optimization of round-robin scheduling\n", + "- Variable property optimization\n", + "- Optimization to reduce false sharing problem\n", + "\n", + "In the following chapters of this book, we will introduce how to create parallel programs using OpenMP based on three different architectures, and explain how to optimize performance based on some of the ideas mentioned above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbd571ae-00fe-4fcc-83f0-e121b680573f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 943c37d01f4af6cb6408fb745b081414c83446f4 Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 27 Jul 2022 09:52:36 -0400 Subject: [PATCH 08/91] Update _toc.yml --- src/_toc.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/src/_toc.yml b/src/_toc.yml index c61490b..1edee54 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -4,7 +4,6 @@ format: jb-book root: intro chapters: -- file: content - file: openmpIntro sections: - file: openmp_c/1_IntroductionOfOpenMP.ipynb From 9aff5f10d8b145aff502380ac17fa5f10ab4c31d Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 27 Jul 2022 09:52:55 -0400 Subject: [PATCH 09/91] Delete content.md --- src/content.md | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 src/content.md diff --git a/src/content.md b/src/content.md deleted file mode 100644 index 0f6aca7..0000000 --- a/src/content.md +++ /dev/null @@ -1,5 +0,0 @@ -Content in Jupyter Book -======================= - -There are many ways to write content in Jupyter Book. This short section -covers a few tips for how to do so. From 3d3a938066223493d8bae7a756572af4c9902415 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 09:58:51 -0400 Subject: [PATCH 10/91] Update openmpIntro.md --- src/openmpIntro.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/openmpIntro.md b/src/openmpIntro.md index 82310a8..a198e13 100644 --- a/src/openmpIntro.md +++ b/src/openmpIntro.md @@ -1 +1 @@ -# OpenMP +# Chapter 1 OpenMP From fc97e35fe34591573aa3c7caf0df7bf5765d8234 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 09:59:32 -0400 Subject: [PATCH 11/91] Update MulticoreMultiCPU.md --- src/MulticoreMultiCPU.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/MulticoreMultiCPU.md b/src/MulticoreMultiCPU.md index 8738b0f..b6a0666 100644 --- a/src/MulticoreMultiCPU.md +++ b/src/MulticoreMultiCPU.md @@ -1,5 +1,5 @@ -# Parallel Programming for Multicore and Multi-CPU Machines +# Chapter 2 Parallel Programming for Multicore and Multi-CPU Machines Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. -In this book, we will be discussing multicore and multi CPU machines and how they work, how to use them, and how to optimize your code to use them effectively. \ No newline at end of file +In this book, we will be discussing multicore and multi CPU machines and how they work, how to use them, and how to optimize your code to use them effectively. From e470ddb055e85c0958666a97cdbd18ded663f2a1 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 09:59:59 -0400 Subject: [PATCH 12/91] Update SIMDVector.md --- src/SIMDVector.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/SIMDVector.md b/src/SIMDVector.md index 54df4f3..22b2e0e 100644 --- a/src/SIMDVector.md +++ b/src/SIMDVector.md @@ -1,4 +1,4 @@ -Parallel Programming for SIMD and Vector Architecture +Chapter 3 Parallel Programming for SIMD and Vector Architecture ===================================================== -Temporary page indicating start of a section \ No newline at end of file +Temporary page indicating start of a section From 3ded1ebac630c4f04e67c46962a47887f221a3c5 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:00:31 -0400 Subject: [PATCH 13/91] Update GPUAccel.md --- src/GPUAccel.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/GPUAccel.md b/src/GPUAccel.md index 6e5bb00..5e0409a 100644 --- a/src/GPUAccel.md +++ b/src/GPUAccel.md @@ -1,4 +1,4 @@ -Parallel Programming for GPU Accelerators +Chapter 4 Parallel Programming for GPU Accelerators ========================================= GPUAccel -Temporary page indicating start of a section \ No newline at end of file +Temporary page indicating start of a section From 16adff24801478b969e2f8b1174d245ba822d24e Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Wed, 27 Jul 2022 10:02:20 -0400 Subject: [PATCH 14/91] Update _toc.yml --- src/_toc.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/_toc.yml b/src/_toc.yml index 1edee54..fac6f83 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -3,6 +3,8 @@ # format: jb-book root: intro +options: + numbered: true chapters: - file: openmpIntro sections: From 23e13482058e5165cff6c4079f1912cf8121c975 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:03:31 -0400 Subject: [PATCH 15/91] Update _config.yml --- src/_config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/_config.yml b/src/_config.yml index a95e461..c8a7379 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -24,7 +24,7 @@ bibtex_bibfiles: # Information about where the book exists on the web repository: - url: https://github.com/XinyaoYI/OpenMPProgrammingBookTest # Online location of your book + url: https://github.com/passlab/OpenMPProgrammingBook # Online location of your book path_to_book: src # Optional path to your book, relative to the repository root branch: main # Which branch of the repository should be used when creating links (optional) From b5d90e8c8b2c893ac6a97b31dfdebee9cc5118fc Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:05:57 -0400 Subject: [PATCH 16/91] Update and rename GPUAccel.md to Ch2_GPUAccel.md --- src/{GPUAccel.md => Ch2_GPUAccel.md} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/{GPUAccel.md => Ch2_GPUAccel.md} (64%) diff --git a/src/GPUAccel.md b/src/Ch2_GPUAccel.md similarity index 64% rename from src/GPUAccel.md rename to src/Ch2_GPUAccel.md index 5e0409a..7abc9ea 100644 --- a/src/GPUAccel.md +++ b/src/Ch2_GPUAccel.md @@ -1,4 +1,4 @@ -Chapter 4 Parallel Programming for GPU Accelerators +Parallel Programming for GPU Accelerators ========================================= GPUAccel Temporary page indicating start of a section From a23f6f9908b9fff3eaeeceaf48bff7c4b6c17b0a Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:06:09 -0400 Subject: [PATCH 17/91] Rename Ch2_GPUAccel.md to Ch4_GPUAccel.md --- src/{Ch2_GPUAccel.md => Ch4_GPUAccel.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{Ch2_GPUAccel.md => Ch4_GPUAccel.md} (100%) diff --git a/src/Ch2_GPUAccel.md b/src/Ch4_GPUAccel.md similarity index 100% rename from src/Ch2_GPUAccel.md rename to src/Ch4_GPUAccel.md From dea98263b1fb743a6759bb040ef6342ba2e74a20 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:06:27 -0400 Subject: [PATCH 18/91] Update and rename MulticoreMultiCPU.md to Ch2_MulticoreMultiCPU.md --- src/{MulticoreMultiCPU.md => Ch2_MulticoreMultiCPU.md} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/{MulticoreMultiCPU.md => Ch2_MulticoreMultiCPU.md} (94%) diff --git a/src/MulticoreMultiCPU.md b/src/Ch2_MulticoreMultiCPU.md similarity index 94% rename from src/MulticoreMultiCPU.md rename to src/Ch2_MulticoreMultiCPU.md index b6a0666..feac574 100644 --- a/src/MulticoreMultiCPU.md +++ b/src/Ch2_MulticoreMultiCPU.md @@ -1,4 +1,4 @@ -# Chapter 2 Parallel Programming for Multicore and Multi-CPU Machines +# Parallel Programming for Multicore and Multi-CPU Machines Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. From 729b9e116106c1c4450f0851456fde88174f2364 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:06:49 -0400 Subject: [PATCH 19/91] Update and rename SIMDVector.md to Ch3_SIMDVector.md --- src/{SIMDVector.md => Ch3_SIMDVector.md} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/{SIMDVector.md => Ch3_SIMDVector.md} (60%) diff --git a/src/SIMDVector.md b/src/Ch3_SIMDVector.md similarity index 60% rename from src/SIMDVector.md rename to src/Ch3_SIMDVector.md index 22b2e0e..44fa7b8 100644 --- a/src/SIMDVector.md +++ b/src/Ch3_SIMDVector.md @@ -1,4 +1,4 @@ -Chapter 3 Parallel Programming for SIMD and Vector Architecture +Parallel Programming for SIMD and Vector Architecture ===================================================== Temporary page indicating start of a section From 90424f7bd8937fb3bcd8a7892575ad2083cdfa11 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:07:49 -0400 Subject: [PATCH 20/91] Update and rename openmpIntro.md to Ch1_openmpIntro.md --- src/Ch1_openmpIntro.md | 1 + src/openmpIntro.md | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 src/Ch1_openmpIntro.md delete mode 100644 src/openmpIntro.md diff --git a/src/Ch1_openmpIntro.md b/src/Ch1_openmpIntro.md new file mode 100644 index 0000000..aaa485a --- /dev/null +++ b/src/Ch1_openmpIntro.md @@ -0,0 +1 @@ +# Overview of OpenMP Programming diff --git a/src/openmpIntro.md b/src/openmpIntro.md deleted file mode 100644 index a198e13..0000000 --- a/src/openmpIntro.md +++ /dev/null @@ -1 +0,0 @@ -# Chapter 1 OpenMP From 04684e3a2ae240389acc986103b55c557648795b Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:08:23 -0400 Subject: [PATCH 21/91] Rename intro.md to Ch0_intro.md --- src/{intro.md => Ch0_intro.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{intro.md => Ch0_intro.md} (100%) diff --git a/src/intro.md b/src/Ch0_intro.md similarity index 100% rename from src/intro.md rename to src/Ch0_intro.md From 80c8fbb049faff2d5ae6a9ab1a8f85c855cfef65 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:09:24 -0400 Subject: [PATCH 22/91] Create preface.md --- src/preface.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/preface.md diff --git a/src/preface.md b/src/preface.md new file mode 100644 index 0000000..6d47ec1 --- /dev/null +++ b/src/preface.md @@ -0,0 +1,4 @@ +# OpenMP Programming Book +================= + +Author: From 134d6e3a1c8eb78c945cd1fd99825587cd1ec6bc Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:17:41 -0400 Subject: [PATCH 23/91] Update _toc.yml --- src/_toc.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/_toc.yml b/src/_toc.yml index fac6f83..fa3ce32 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -2,24 +2,24 @@ # Learn more at https://jupyterbook.org/customize/toc.html # format: jb-book -root: intro +root: Ch0_intro options: numbered: true chapters: -- file: openmpIntro +- file: Ch1_openmpIntro sections: - file: openmp_c/1_IntroductionOfOpenMP.ipynb - file: openmp_c/2_Syntax.ipynb - file: openmp_c/3_performance.ipynb -- file: MulticoreMultiCPU +- file: Ch2_MulticoreMultiCPU sections: - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb - file: MultiCoreMultiCPU/2_UsingOpenMP.ipynb - file: MultiCoreMultiCPU/3_SynchronizationThreads.ipynb - file: MultiCoreMultiCPU/4_AsynchronousTasking.ipynb - file: MultiCoreMultiCPU/5_ExplicitDistribution.ipynb -- file: SIMDVector -- file: GPUAccel +- file: Ch3_SIMDVector +- file: Ch4_GPUAccel sections: - file: GPUAccelerators/1_DataMapping.ipynb - file: GPUAccelerators/2_Metadirective.ipynb From 7b857b8fa4ebf9132aa14ca40c18e65612aec735 Mon Sep 17 00:00:00 2001 From: Xinyao YI Date: Wed, 27 Jul 2022 10:18:41 -0400 Subject: [PATCH 24/91] Update Ch0_intro.md --- src/Ch0_intro.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/Ch0_intro.md b/src/Ch0_intro.md index ef85c3d..4b17bde 100644 --- a/src/Ch0_intro.md +++ b/src/Ch0_intro.md @@ -1,4 +1,11 @@ -Introduction +# OpenMP Programming Book + +========================= + +Authors: + + +# Introduction ============================ This is a small sample book to give you a feel for how book content is From 50938f931d1bb094c5f24072c0aaa448b1651052 Mon Sep 17 00:00:00 2001 From: xinyao Date: Tue, 2 Aug 2022 17:57:47 -0400 Subject: [PATCH 25/91] Change the strcuture, add preface --- src/Ch0_intro.md | 14 -------------- src/_toc.yml | 48 +++++++++++++++++++++++++---------------------- src/book_intro.md | 1 + src/copyright.md | 3 +++ src/cover.md | 5 +++++ src/foreword.md | 3 +++ src/preface.md | 6 ++---- 7 files changed, 40 insertions(+), 40 deletions(-) delete mode 100644 src/Ch0_intro.md create mode 100644 src/book_intro.md create mode 100644 src/copyright.md create mode 100644 src/cover.md create mode 100644 src/foreword.md diff --git a/src/Ch0_intro.md b/src/Ch0_intro.md deleted file mode 100644 index 4b17bde..0000000 --- a/src/Ch0_intro.md +++ /dev/null @@ -1,14 +0,0 @@ -# OpenMP Programming Book - -========================= - -Authors: - - -# Introduction -============================ - -This is a small sample book to give you a feel for how book content is -structured. - -Check out the content pages bundled with this sample book to get started. diff --git a/src/_toc.yml b/src/_toc.yml index fa3ce32..117d57d 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -2,25 +2,29 @@ # Learn more at https://jupyterbook.org/customize/toc.html # format: jb-book -root: Ch0_intro -options: - numbered: true -chapters: -- file: Ch1_openmpIntro - sections: - - file: openmp_c/1_IntroductionOfOpenMP.ipynb - - file: openmp_c/2_Syntax.ipynb - - file: openmp_c/3_performance.ipynb -- file: Ch2_MulticoreMultiCPU - sections: - - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb - - file: MultiCoreMultiCPU/2_UsingOpenMP.ipynb - - file: MultiCoreMultiCPU/3_SynchronizationThreads.ipynb - - file: MultiCoreMultiCPU/4_AsynchronousTasking.ipynb - - file: MultiCoreMultiCPU/5_ExplicitDistribution.ipynb -- file: Ch3_SIMDVector -- file: Ch4_GPUAccel - sections: - - file: GPUAccelerators/1_DataMapping.ipynb - - file: GPUAccelerators/2_Metadirective.ipynb - +root: cover +parts: + - chapters: + - file: copyright + - file: book_intro + - file: foreword + - file: preface + - numbered: True + chapters: + - file: Ch1_openmpIntro + sections: + - file: openmp_c/1_IntroductionOfOpenMP.ipynb + - file: openmp_c/2_Syntax.ipynb + - file: openmp_c/3_performance.ipynb + - file: Ch2_MulticoreMultiCPU + sections: + - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb + - file: MultiCoreMultiCPU/2_UsingOpenMP.ipynb + - file: MultiCoreMultiCPU/3_SynchronizationThreads.ipynb + - file: MultiCoreMultiCPU/4_AsynchronousTasking.ipynb + - file: MultiCoreMultiCPU/5_ExplicitDistribution.ipynb + - file: Ch3_SIMDVector + - file: Ch4_GPUAccel + sections: + - file: GPUAccelerators/1_DataMapping.ipynb + - file: GPUAccelerators/2_Metadirective.ipynb \ No newline at end of file diff --git a/src/book_intro.md b/src/book_intro.md new file mode 100644 index 0000000..f4792d3 --- /dev/null +++ b/src/book_intro.md @@ -0,0 +1 @@ +This is a brief introduction to give you a feel for how book content is structured. diff --git a/src/copyright.md b/src/copyright.md new file mode 100644 index 0000000..aa8a154 --- /dev/null +++ b/src/copyright.md @@ -0,0 +1,3 @@ +# copyright +Here is the publication information. +For example, when published? the copyright? funding? \ No newline at end of file diff --git a/src/cover.md b/src/cover.md new file mode 100644 index 0000000..ddc8c4c --- /dev/null +++ b/src/cover.md @@ -0,0 +1,5 @@ +# OpenMP Programming Book + +====================================== + +Authors: \ No newline at end of file diff --git a/src/foreword.md b/src/foreword.md new file mode 100644 index 0000000..ca079cb --- /dev/null +++ b/src/foreword.md @@ -0,0 +1,3 @@ +# foreword + +This is foreword from other people. \ No newline at end of file diff --git a/src/preface.md b/src/preface.md index 6d47ec1..d4a9d9e 100644 --- a/src/preface.md +++ b/src/preface.md @@ -1,4 +1,2 @@ -# OpenMP Programming Book -================= - -Author: +# preface +This is preface from the author \ No newline at end of file From 8097072e35f9be84d91ed603e7dfbc4974efd3cd Mon Sep 17 00:00:00 2001 From: xinyao Date: Tue, 2 Aug 2022 23:37:04 -0400 Subject: [PATCH 26/91] Added section 2.2 --- .../1_MIMDArchitecture.ipynb | 2 +- src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb | 77 +++++++++++++++++- src/MultiCoreMultiCPU/teams.jpeg | Bin 0 -> 43441 bytes 3 files changed, 76 insertions(+), 3 deletions(-) create mode 100644 src/MultiCoreMultiCPU/teams.jpeg diff --git a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb index 6f502c8..5ccd5ab 100644 --- a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb +++ b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -55,7 +55,7 @@ "## Multicore Systems\n", "Multicore machines just mean that the computer has “n” number of central processing units. Although these processors have multiple cores they still fit in one CPU slot on a motherboard all using the same power, cooling, and other hardware.\n", "\n", - "Let's look at a multi-core example as shown below:\n", + "A multi-core example is shown below:\n", "![Multi_CPU_systems_model1](CPU_architecture.png \"topic1\")\n", "\n", "Only two cores are shown in this diagram, but real multi-core processors tend to use more cores. Multiple threads can be loaded onto a core for execution.\n", diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb index 70131d3..7d244bf 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb @@ -5,7 +5,7 @@ "id": "3f8a3d29-cc57-49bc-88f7-5602d4491cae", "metadata": {}, "source": [ - "# Creating SPMD parallelism using OpenMP parallel and teams directive" + "# Creating SPMD parallelism using OpenMP **parallel** and **teams** directive" ] }, { @@ -13,7 +13,80 @@ "id": "80396b0a-815f-4004-b29a-b53a47db1c15", "metadata": {}, "source": [ - "## \n" + "From this part, we begin to introduce how to use OpenMP directives to write programs. We first introduce the most basic and most commonly used **parallel** directive and **teams** directive." + ] + }, + { + "cell_type": "markdown", + "id": "9c771a6f-d5c6-45df-ab93-d28e8fdb6d9c", + "metadata": {}, + "source": [ + "## Semantics and Syntax\n", + "\n", + "### **parallel** Directive\n", + "The **parallel** directive is used to mark a parallel region. When a thread encounters a parallel region, a group of threads is created to execute the parallel region. Its syntax in C is:\n", + "\n", + "```\n", + "#pragma omp parallel [clause[ [,] clause] ... ] new-line\n", + " structured-block\n", + "```\n", + "The syntax in Fortran is:\n", + "```\n", + "!$omp parallel do [clause[ [,] clause] ... ]\n", + " loop-nest\n", + "[!$omp end parallel do]\n", + "```\n", + "The original thread that executed the serial part will be the primary thread of the new team. All threads in the team execute parallel regions together. After a team is created, the number of threads in the team remains constant for the duration of that parallel region.\n", + "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the *omp_get_thread_num* library routine.\n", + "> Primary thread is also known as the master thread\n", + "\n", + "When a thread team is created, the primary thread will implicitly create as many tasks as the number of threads, each task is assigned and bounded to one thread.\n", + "When threads are all occupied, implicit tasks that have not been allocated will be suspended waiting for idle threads.\n", + "\n", + "### **teams** Directive\n", + "The **teams** directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the **teams** directive to use a large number of thread teams.\n", + "Its syntax is:\n", + "```\n", + "#pragma omp teams [clause[ [,] clause] ... ] new-line\n", + " structured-block\n", + "```\n", + "The syntax in Fortran is:\n", + "```\n", + "!$omp teams [clause[ [,] clause] ... ]\n", + " loosely-structured-block\n", + "!$omp end teams\n", + "```\n", + "The following figure shows the execution model of the **teams** directive:\n", + "![teams_directive](teams.jpeg \"topic1\")\n", + "\n", + "A league of teams is created when a thread encounters a **teams** construct. Each team is an initial team, and the initial thread in each team executes the team area.\n", + "After a team is created, the number of initial teams remains the same for the duration of the **teams** region.\n", + "Within a **teams** region, the initial team number uniquely identifies each initial team. A thread can obtain its own initial team number by calling the *omp_get_team_num* library routine.\n", + "The teams directive has the following characteristics:\n", + "- the **teams** directive can spawn one or more thread teams with the same number of threads\n", + "- code is portable for one thread team or multiple thread teams\n", + "- only the primary thread of each team continues to execute\n", + "- no synchronization between thread teams\n", + "- programmers don't need to think about how to decompose loops\n", + "\n", + "OpenMP was originally designed for multithreading on shared-memory parallel computers, so the parallel directive only creates a single layer of parallelism.\n", + "The team instruction is used to express the second level of scalable parallelization, which can be used not only on the CPU, but also on the GPU.\n" + ] + }, + { + "cell_type": "markdown", + "id": "45ca913b-05d5-4e99-bf47-bd07d60c6348", + "metadata": {}, + "source": [ + "## Clauses" + ] + }, + { + "cell_type": "markdown", + "id": "42d3cfb9-b7ad-4deb-b3bc-c2787f6f1006", + "metadata": {}, + "source": [ + "## Examples" ] } ], diff --git a/src/MultiCoreMultiCPU/teams.jpeg b/src/MultiCoreMultiCPU/teams.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..31119a038f56ada966e1fb115430f7bc77694414 GIT binary patch literal 43441 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 k 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 Wdvu4-$m|N6{`n93ABxI<5B>vIt+bl} literal 0 HcmV?d00001 From ef2fd797ac9faa9059900ee2eb242fe973c3b145 Mon Sep 17 00:00:00 2001 From: xinyao Date: Mon, 22 Aug 2022 11:46:59 -0400 Subject: [PATCH 27/91] Added some contents for section chapter2-section2 --- src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb | 431 ++++++++++++++++++++-- 1 file changed, 398 insertions(+), 33 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb index 7d244bf..2edc2a7 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb @@ -18,44 +18,312 @@ }, { "cell_type": "markdown", - "id": "9c771a6f-d5c6-45df-ab93-d28e8fdb6d9c", + "id": "64eed9ee-4096-4c94-85c4-541f0e1fd003", "metadata": {}, "source": [ "## Semantics and Syntax\n", "\n", "### **parallel** Directive\n", - "The **parallel** directive is used to mark a parallel region. When a thread encounters a parallel region, a group of threads is created to execute the parallel region. Its syntax in C is:\n", + "The **parallel** directive is used to mark a parallel region. When a thread encounters a parallel region, a group of threads is created to execute the parallel region.\n", + "The original thread that executed the serial part will be the primary thread of the new team. All threads in the team execute parallel regions together. After a team is created, the number of threads in the team remains constant for the duration of that parallel region.\n", + "\n", + "> Primary thread is also known as the master thread\n", + "\n", + "When a thread team is created, the primary thread will implicitly create as many tasks as the number of threads, each task is assigned and bounded to one thread.\n", + "When threads are all occupied, implicit tasks that have not been allocated will be suspended waiting for idle threads.\n", + "\n", + "The following example from Chapter 1 shows how to use the parallel directive in C." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fd26e7ea-54ed-4422-8880-3eaeddcf05bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + " #pragma omp parallel\n", + " printf(\"%s\\n\", \"Hello World\");\n", + " \n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "876b7000-4951-4d79-9ee6-cb68e401351e", + "metadata": {}, + "source": [ + "This example prints *Hello World* 8 times, which means 8 threads are created by defualt. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", + "The following example shows how to use the num_threads clause in the parallel directive to specify the number of threads to create." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2ba3b85f-e4ed-440e-9aa3-b7bf65153dec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + " #pragma omp parallel num_threads(4)\n", + " printf(\"%s\\n\", \"Hello World\");\n", + " \n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "543226c1-8e46-4695-b805-129970ab8d45", + "metadata": {}, + "source": [ + "In this example, we use the **num_threads** clause to specify the use of 4 threads to execute the parallel region. When the master thread encounters OpenMP constructs, three threads are created, and together with these three threads, a thread group of 4 is formed. \n", + "*Hello World* is printed four times, once per thread.\n", + "\n", + "Through the above examples, it is not difficult to find that the syntax of parallel directive in C is:\n", "\n", "```\n", "#pragma omp parallel [clause[ [,] clause] ... ] new-line\n", " structured-block\n", "```\n", - "The syntax in Fortran is:\n", + "\n", + "And the syntax of **num_threads** clause is：\n", + "\n", + "```\n", + "num_threads(integer-expression)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "57cc59fe-6c16-4926-beaa-9eea9873871f", + "metadata": {}, + "source": [ + "The next two examples show how to use **paralle** diretcive in Fortran, and they have exactly same meaning as the two examples in C above." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e1e4db67-3b78-4842-9dde-9dea1bba23c7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n" + ] + } + ], + "source": [ + "!!%compiler: gfortran\n", + "!!%cflags: -fopenmp\n", + "\n", + "PROGRAM Parallel_Hello_World\n", + "USE OMP_LIB\n", + "\n", + "!$OMP PARALLEL\n", + "\n", + " PRINT *, \"Hello World\"\n", + "\n", + "!$OMP END PARALLEL\n", + "\n", + "END" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "888dc7e0-538f-41a7-8a2e-f9f9fb992e66", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n" + ] + } + ], + "source": [ + "!!%compiler: gfortran\n", + "!!%cflags: -fopenmp\n", + "\n", + "PROGRAM Parallel_Hello_World\n", + "USE OMP_LIB\n", + "\n", + "!$OMP PARALLEL num_threads(4)\n", + "\n", + " PRINT *, \"Hello World\"\n", + "\n", + "!$OMP END PARALLEL\n", + "\n", + "END" + ] + }, + { + "cell_type": "markdown", + "id": "9c771a6f-d5c6-45df-ab93-d28e8fdb6d9c", + "metadata": {}, + "source": [ + "The syntax of **parallel** directive in Fortran is:\n", "```\n", "!$omp parallel do [clause[ [,] clause] ... ]\n", " loop-nest\n", "[!$omp end parallel do]\n", "```\n", - "The original thread that executed the serial part will be the primary thread of the new team. All threads in the team execute parallel regions together. After a team is created, the number of threads in the team remains constant for the duration of that parallel region.\n", - "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the *omp_get_thread_num* library routine.\n", - "> Primary thread is also known as the master thread\n", "\n", - "When a thread team is created, the primary thread will implicitly create as many tasks as the number of threads, each task is assigned and bounded to one thread.\n", - "When threads are all occupied, implicit tasks that have not been allocated will be suspended waiting for idle threads.\n", + "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the **omp_get_thread_num** library routine.\n", + "\n", + "The following example is a little more complicated. It shows how to use the **omp_get_thread_num** library routine, and shows how to use two other clauses, the **default** clause and the **private** clause. It assigns tasks to each thread explicitly." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6ae89f0f-992c-4f53-a51f-aa82b8a1f29e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 \n", + "123.456001 123.456001 123.456001 123.456001 123.456001 " + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "void subdomain(float *x, int istart, int ipoints) {\n", + " int i;\n", + " for (i = 0; i < ipoints; i++) \n", + " x[istart+i] = 123.456;\n", + "}\n", + "\n", + "void sub(float *x, int npoints) {\n", + " int iam, nt, ipoints, istart;\n", + " #pragma omp parallel default(shared) private(iam,nt,ipoints,istart)\n", + " {\n", + " iam = omp_get_thread_num();\n", + " nt = omp_get_num_threads();\n", + " ipoints = npoints / nt; /* size of partition */\n", + " istart = iam * ipoints; /* starting array index */\n", + " if (iam == nt-1) /* last thread may do more */\n", + " ipoints = npoints - istart;\n", + " subdomain(x, istart, ipoints);\n", + " }\n", + "}\n", + "\n", + "void print(float *x, int npoints) {\n", + " for (int i = 0; i < npoints; i++) {\n", + " if(i++ % 10 == 0)\n", + " printf(\"\\n\");\n", + " printf(\"%f \", x[i]);\n", + " }\n", + "}\n", + "\n", + "int main() {\n", + " float array[100];\n", + " sub(array, 100);\n", + " print(array, 100);\n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "1aa77bdb-821b-4cfa-a70b-04ae5fc1e40a", + "metadata": {}, + "source": [ + "In the above example, we use the default number of threads to perform assignment operations on 100 elements in the array. Tasks are evenly distributed to each thread, and when the number of tasks is not divisible by the number of threads, the remaining tasks will be completed by the last thread.\n", "\n", + "When programming in parallel, the most important and hardest part is how to assign tasks and manage threads. We already introduced that a thread can get its own id through the **omp_get_thread_num** routine. Another important routine is **omp_get_num_threads**, which returns the number of threads in the current team.\n", + "\n", + "In the above example, variable *npoints* presents the total number of elements in the array, and it is divided into *nt* parts, each of size *ipoints*. The starting address of each part is *istart*. Each part is completed by one thread, and a total of 8 threads execute tasks in parallel.\n", + "\n", + "The **default** clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task generating construct. In the above example, *default(shared)* indicates that by default, the variables in the parallel region are shared variables.\n", + "The **private** clause is used to explicitly specify variables that are private in each task or SIMD lane (SIMD will be introduced in the next chapter). In the above example, the variables *iam, nt, ipoints* and *istart* are private variables for each thread, which means a thread cannot access these variables of another thread.\n", + "\n", + "Both of these two clauses belong to the data-sharing attribute clauses, which we will introduce in detail in the section of clauses later." + ] + }, + { + "cell_type": "markdown", + "id": "ab22416e-34dc-4379-8fec-96848d9b31c7", + "metadata": {}, + "source": [ "### **teams** Directive\n", "The **teams** directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the **teams** directive to use a large number of thread teams.\n", - "Its syntax is:\n", - "```\n", - "#pragma omp teams [clause[ [,] clause] ... ] new-line\n", - " structured-block\n", - "```\n", - "The syntax in Fortran is:\n", - "```\n", - "!$omp teams [clause[ [,] clause] ... ]\n", - " loosely-structured-block\n", - "!$omp end teams\n", - "```\n", + "\n", "The following figure shows the execution model of the **teams** directive:\n", "![teams_directive](teams.jpeg \"topic1\")\n", "\n", @@ -70,7 +338,99 @@ "- programmers don't need to think about how to decompose loops\n", "\n", "OpenMP was originally designed for multithreading on shared-memory parallel computers, so the parallel directive only creates a single layer of parallelism.\n", - "The team instruction is used to express the second level of scalable parallelization, which can be used not only on the CPU, but also on the GPU.\n" + "The team instruction is used to express the second level of scalable parallelization. Before OpenMP 5.0, it can be only used on the GPU (with an associated target construct). In OpenMP 5.0 the **teams** construct was extended to enable the host to execute a teams region.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c9debd7d-fe6d-4a97-90e3-c0cddf29458f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/tmpwit3re_h.c:16:5: error: orphaned 'omp teams' directives are prohibited; perhaps you forget to enclose the directive into a target region?\n", + " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", + " ^\n", + "1 error generated.\n", + "[Native kernel] clang exited with code 1, the executable will not be executed" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "// Need to update the native kernel, or specified that our kernel doesn't support OpenMP 5.0\n", + "\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "#define N 1000\n", + " \n", + "int main(){\n", + " int nteams_required=2, max_thrds, tm_id;\n", + " float sp_x[N], sp_y[N], sp_a=0.0001e0;\n", + " double dp_x[N], dp_y[N], dp_a=0.0001e0;\n", + "\n", + " // Create 2 teams, each team works in a different precision\n", + " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", + " {\n", + " tm_id = omp_get_team_num();\n", + " if( omp_get_num_teams() != 2 ) //if only getting 1, quit \n", + " { \n", + " printf(\"error: Insufficient teams on host, 2 required\\n\");\n", + " exit(0);\n", + " }\n", + " if(tm_id == 0) // Do Single Precision Work (SAXPY) with this team\n", + " {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp for //init\n", + " for(int i=0; i Date: Tue, 23 Aug 2022 11:19:01 -0400 Subject: [PATCH 28/91] Added an example of trams directive. We can only use teams clause with target clause, I cannot compile it on my own computer. --- src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb | 107 ++++++++++++++-------- 1 file changed, 69 insertions(+), 38 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb index 2edc2a7..8043fbd 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "3f8a3d29-cc57-49bc-88f7-5602d4491cae", + "id": "60c352ab", "metadata": {}, "source": [ "# Creating SPMD parallelism using OpenMP **parallel** and **teams** directive" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "80396b0a-815f-4004-b29a-b53a47db1c15", + "id": "cf1c80a7", "metadata": {}, "source": [ "From this part, we begin to introduce how to use OpenMP directives to write programs. We first introduce the most basic and most commonly used **parallel** directive and **teams** directive." @@ -18,7 +18,7 @@ }, { "cell_type": "markdown", - "id": "64eed9ee-4096-4c94-85c4-541f0e1fd003", + "id": "2c6183b8", "metadata": {}, "source": [ "## Semantics and Syntax\n", @@ -37,25 +37,10 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "fd26e7ea-54ed-4422-8880-3eaeddcf05bd", + "execution_count": null, + "id": "00f487b4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n" - ] - } - ], + "outputs": [], "source": [ "//%compiler: clang\n", "//%cflags: -fopenmp\n", @@ -74,7 +59,7 @@ }, { "cell_type": "markdown", - "id": "876b7000-4951-4d79-9ee6-cb68e401351e", + "id": "c9634202", "metadata": {}, "source": [ "This example prints *Hello World* 8 times, which means 8 threads are created by defualt. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", @@ -83,8 +68,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "2ba3b85f-e4ed-440e-9aa3-b7bf65153dec", + "execution_count": 2, + "id": "06a9151e", "metadata": {}, "outputs": [ { @@ -116,7 +101,7 @@ }, { "cell_type": "markdown", - "id": "543226c1-8e46-4695-b805-129970ab8d45", + "id": "63291c66", "metadata": {}, "source": [ "In this example, we use the **num_threads** clause to specify the use of 4 threads to execute the parallel region. When the master thread encounters OpenMP constructs, three threads are created, and together with these three threads, a thread group of 4 is formed. \n", @@ -138,7 +123,7 @@ }, { "cell_type": "markdown", - "id": "57cc59fe-6c16-4926-beaa-9eea9873871f", + "id": "ec4060c3", "metadata": {}, "source": [ "The next two examples show how to use **paralle** diretcive in Fortran, and they have exactly same meaning as the two examples in C above." @@ -147,7 +132,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "e1e4db67-3b78-4842-9dde-9dea1bba23c7", + "id": "f220ae73", "metadata": {}, "outputs": [ { @@ -184,7 +169,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "888dc7e0-538f-41a7-8a2e-f9f9fb992e66", + "id": "d5c99192", "metadata": {}, "outputs": [ { @@ -216,7 +201,7 @@ }, { "cell_type": "markdown", - "id": "9c771a6f-d5c6-45df-ab93-d28e8fdb6d9c", + "id": "03a00d26", "metadata": {}, "source": [ "The syntax of **parallel** directive in Fortran is:\n", @@ -234,7 +219,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "6ae89f0f-992c-4f53-a51f-aa82b8a1f29e", + "id": "229651ad", "metadata": {}, "outputs": [ { @@ -301,7 +286,7 @@ }, { "cell_type": "markdown", - "id": "1aa77bdb-821b-4cfa-a70b-04ae5fc1e40a", + "id": "3a6a9f51", "metadata": {}, "source": [ "In the above example, we use the default number of threads to perform assignment operations on 100 elements in the array. Tasks are evenly distributed to each thread, and when the number of tasks is not divisible by the number of threads, the remaining tasks will be completed by the last thread.\n", @@ -318,7 +303,7 @@ }, { "cell_type": "markdown", - "id": "ab22416e-34dc-4379-8fec-96848d9b31c7", + "id": "e24ad80a", "metadata": {}, "source": [ "### **teams** Directive\n", @@ -341,10 +326,56 @@ "The team instruction is used to express the second level of scalable parallelization. Before OpenMP 5.0, it can be only used on the GPU (with an associated target construct). In OpenMP 5.0 the **teams** construct was extended to enable the host to execute a teams region.\n" ] }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c62d988b-cd16-4ba2-9c6d-1bfe43666a91", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "clang: error: cannot find libdevice for sm_35. Provide path to different CUDA installation via --cuda-path, or pass -nocudalib to build without linking with libdevice.\n", + "[Native kernel] clang exited with code 1, the executable will not be executed" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda --cuda-path=/usr/local/cuda\n", + "#include \n", + "#include \n", + "float dotprod(float B[], float C[], int N) {\n", + " float sum0 = 0.0;\n", + " float sum1 = 0.0;\n", + " #pragma omp target map(to: B[:N], C[:N]) map(tofrom: sum0, sum1)\n", + " #pragma omp teams num_teams(2) \n", + " {\n", + " int i;\n", + " if (omp_get_num_teams() != 2)\n", + " abort();\n", + " if (omp_get_team_num() == 0) {\n", + " #pragma omp parallel for reduction(+:sum0)\n", + " for (i=0; i Date: Mon, 29 Aug 2022 15:14:39 -0400 Subject: [PATCH 29/91] Divide section2.2 into two parts(parallel and teams) since that is too long --- ...nMP.ipynb => 2_UsingOpenMP_parallel.ipynb} | 210 ++++------------ .../3_UsingOpenMP_teams.ipynb | 225 ++++++++++++++++++ ...s.ipynb => 4_SynchronizationThreads.ipynb} | 4 +- ...king.ipynb => 5_AsynchronousTasking.ipynb} | 0 ...ion.ipynb => 6_ExplicitDistribution.ipynb} | 0 src/_toc.yml | 9 +- 6 files changed, 284 insertions(+), 164 deletions(-) rename src/MultiCoreMultiCPU/{2_UsingOpenMP.ipynb => 2_UsingOpenMP_parallel.ipynb} (64%) create mode 100644 src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb rename src/MultiCoreMultiCPU/{3_SynchronizationThreads.ipynb => 4_SynchronizationThreads.ipynb} (89%) rename src/MultiCoreMultiCPU/{4_AsynchronousTasking.ipynb => 5_AsynchronousTasking.ipynb} (100%) rename src/MultiCoreMultiCPU/{5_ExplicitDistribution.ipynb => 6_ExplicitDistribution.ipynb} (100%) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb similarity index 64% rename from src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb rename to src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 8043fbd..6250bb9 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -2,23 +2,23 @@ "cells": [ { "cell_type": "markdown", - "id": "60c352ab", + "id": "6d6f12df", "metadata": {}, "source": [ - "# Creating SPMD parallelism using OpenMP **parallel** and **teams** directive" + "# Creating SPMD parallelism using OpenMP **parallel** directive" ] }, { "cell_type": "markdown", - "id": "cf1c80a7", + "id": "e22c5131", "metadata": {}, "source": [ - "From this part, we begin to introduce how to use OpenMP directives to write programs. We first introduce the most basic and most commonly used **parallel** directive and **teams** directive." + "From this part, we begin to introduce how to use OpenMP directives to write programs. We first introduce the most basic and most commonly used **parallel** directive." ] }, { "cell_type": "markdown", - "id": "2c6183b8", + "id": "89d198a4", "metadata": {}, "source": [ "## Semantics and Syntax\n", @@ -37,10 +37,29 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "00f487b4", + "execution_count": 1, + "id": "e14d751a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], "source": [ "//%compiler: clang\n", "//%cflags: -fopenmp\n", @@ -59,7 +78,7 @@ }, { "cell_type": "markdown", - "id": "c9634202", + "id": "7332a65a", "metadata": {}, "source": [ "This example prints *Hello World* 8 times, which means 8 threads are created by defualt. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", @@ -68,21 +87,10 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "06a9151e", + "execution_count": null, + "id": "3cf85b73", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n" - ] - } - ], + "outputs": [], "source": [ "//%compiler: clang\n", "//%cflags: -fopenmp\n", @@ -101,7 +109,7 @@ }, { "cell_type": "markdown", - "id": "63291c66", + "id": "f0ae9969", "metadata": {}, "source": [ "In this example, we use the **num_threads** clause to specify the use of 4 threads to execute the parallel region. When the master thread encounters OpenMP constructs, three threads are created, and together with these three threads, a thread group of 4 is formed. \n", @@ -123,7 +131,7 @@ }, { "cell_type": "markdown", - "id": "ec4060c3", + "id": "0b8fbc89", "metadata": {}, "source": [ "The next two examples show how to use **paralle** diretcive in Fortran, and they have exactly same meaning as the two examples in C above." @@ -132,7 +140,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "f220ae73", + "id": "29b05917", "metadata": {}, "outputs": [ { @@ -169,7 +177,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "d5c99192", + "id": "eb7e4cbd", "metadata": {}, "outputs": [ { @@ -201,7 +209,7 @@ }, { "cell_type": "markdown", - "id": "03a00d26", + "id": "b39385c2", "metadata": {}, "source": [ "The syntax of **parallel** directive in Fortran is:\n", @@ -219,7 +227,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "229651ad", + "id": "b1908c43", "metadata": {}, "outputs": [ { @@ -286,7 +294,7 @@ }, { "cell_type": "markdown", - "id": "3a6a9f51", + "id": "20db34ef", "metadata": {}, "source": [ "In the above example, we use the default number of threads to perform assignment operations on 100 elements in the array. Tasks are evenly distributed to each thread, and when the number of tasks is not divisible by the number of threads, the remaining tasks will be completed by the last thread.\n", @@ -303,79 +311,31 @@ }, { "cell_type": "markdown", - "id": "e24ad80a", + "id": "18848ac3", "metadata": {}, - "source": [ - "### **teams** Directive\n", - "The **teams** directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the **teams** directive to use a large number of thread teams.\n", - "\n", - "The following figure shows the execution model of the **teams** directive:\n", - "![teams_directive](teams.jpeg \"topic1\")\n", - "\n", - "A league of teams is created when a thread encounters a **teams** construct. Each team is an initial team, and the initial thread in each team executes the team area.\n", - "After a team is created, the number of initial teams remains the same for the duration of the **teams** region.\n", - "Within a **teams** region, the initial team number uniquely identifies each initial team. A thread can obtain its own initial team number by calling the *omp_get_team_num* library routine.\n", - "The teams directive has the following characteristics:\n", - "- the **teams** directive can spawn one or more thread teams with the same number of threads\n", - "- code is portable for one thread team or multiple thread teams\n", - "- only the primary thread of each team continues to execute\n", - "- no synchronization between thread teams\n", - "- programmers don't need to think about how to decompose loops\n", - "\n", - "OpenMP was originally designed for multithreading on shared-memory parallel computers, so the parallel directive only creates a single layer of parallelism.\n", - "The team instruction is used to express the second level of scalable parallelization. Before OpenMP 5.0, it can be only used on the GPU (with an associated target construct). In OpenMP 5.0 the **teams** construct was extended to enable the host to execute a teams region.\n" - ] + "source": [] }, { "cell_type": "code", - "execution_count": 10, - "id": "c62d988b-cd16-4ba2-9c6d-1bfe43666a91", + "execution_count": 2, + "id": "897482af", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "clang: error: cannot find libdevice for sm_35. Provide path to different CUDA installation via --cuda-path, or pass -nocudalib to build without linking with libdevice.\n", + "clang: fatal error: cannot find libdevice for sm_35. Provide path to different CUDA installation via --cuda-path, or pass -nocudalib to build without linking with libdevice.\n", "[Native kernel] clang exited with code 1, the executable will not be executed" ] } ], - "source": [ - "//%compiler: clang\n", - "//%cflags: -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda --cuda-path=/usr/local/cuda\n", - "#include \n", - "#include \n", - "float dotprod(float B[], float C[], int N) {\n", - " float sum0 = 0.0;\n", - " float sum1 = 0.0;\n", - " #pragma omp target map(to: B[:N], C[:N]) map(tofrom: sum0, sum1)\n", - " #pragma omp teams num_teams(2) \n", - " {\n", - " int i;\n", - " if (omp_get_num_teams() != 2)\n", - " abort();\n", - " if (omp_get_team_num() == 0) {\n", - " #pragma omp parallel for reduction(+:sum0)\n", - " for (i=0; i\n", - "#include \n", - "#include \n", - "#include \n", - "#define N 1000\n", - " \n", - "int main(){\n", - " int nteams_required=2, max_thrds, tm_id;\n", - " float sp_x[N], sp_y[N], sp_a=0.0001e0;\n", - " double dp_x[N], dp_y[N], dp_a=0.0001e0;\n", - "\n", - " // Create 2 teams, each team works in a different precision\n", - " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", - " {\n", - " tm_id = omp_get_team_num();\n", - " if( omp_get_num_teams() != 2 ) //if only getting 1, quit \n", - " { \n", - " printf(\"error: Insufficient teams on host, 2 required\\n\");\n", - " exit(0);\n", - " }\n", - " if(tm_id == 0) // Do Single Precision Work (SAXPY) with this team\n", - " {\n", - " #pragma omp parallel\n", - " {\n", - " #pragma omp for //init\n", - " for(int i=0; i\n", + "#include \n", + "float dotprod(float B[], float C[], int N) {\n", + " float sum0 = 0.0;\n", + " float sum1 = 0.0;\n", + " #pragma omp target map(to: B[:N], C[:N]) map(tofrom: sum0, sum1)\n", + " #pragma omp teams num_teams(2) \n", + " {\n", + " int i;\n", + " if (omp_get_num_teams() != 2)\n", + " abort();\n", + " if (omp_get_team_num() == 0) {\n", + " #pragma omp parallel for reduction(+:sum0)\n", + " for (i=0; i\n", + "#include \n", + "#include \n", + "#include \n", + "#define N 1000\n", + " \n", + "int main(){\n", + " int nteams_required=2, max_thrds, tm_id;\n", + " float sp_x[N], sp_y[N], sp_a=0.0001e0;\n", + " double dp_x[N], dp_y[N], dp_a=0.0001e0;\n", + "\n", + " // Create 2 teams, each team works in a different precision\n", + " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", + " {\n", + " tm_id = omp_get_team_num();\n", + " if( omp_get_num_teams() != 2 ) //if only getting 1, quit \n", + " { \n", + " printf(\"error: Insufficient teams on host, 2 required\\n\");\n", + " exit(0);\n", + " }\n", + " if(tm_id == 0) // Do Single Precision Work (SAXPY) with this team\n", + " {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp for //init\n", + " for(int i=0; i Date: Wed, 31 Aug 2022 09:08:53 -0400 Subject: [PATCH 30/91] Added the Fortran example --- .../2_UsingOpenMP_parallel.ipynb | 121 ++++++++++-------- .../3_UsingOpenMP_teams.ipynb | 17 ++- 2 files changed, 81 insertions(+), 57 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 6250bb9..12663f0 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -139,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "id": "29b05917", "metadata": {}, "outputs": [ @@ -154,6 +154,10 @@ " Hello World\n", " Hello World\n", " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", + " Hello World\n", " Hello World\n" ] } @@ -226,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 67, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -234,23 +238,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 \n", - "123.456001 123.456001 123.456001 123.456001 123.456001 " + "0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000 " ] } ], "source": [ "//%compiler: clang\n", "//%cflags: -fopenmp\n", + "//This example is from https://www.openmp.org/wp-content/uploads/openmp-examples-5.1.pdf. The size of array and output are changed\n", "\n", "#include \n", "#include \n", @@ -259,7 +254,7 @@ "void subdomain(float *x, int istart, int ipoints) {\n", " int i;\n", " for (i = 0; i < ipoints; i++) \n", - " x[istart+i] = 123.456;\n", + " x[istart+i] = istart+i;\n", "}\n", "\n", "void sub(float *x, int npoints) {\n", @@ -278,9 +273,7 @@ "\n", "void print(float *x, int npoints) {\n", " for (int i = 0; i < npoints; i++) {\n", - " if(i++ % 10 == 0)\n", - " printf(\"\\n\");\n", - " printf(\"%f \", x[i]);\n", + " printf(\"%.5f \", x[i]);\n", " }\n", "}\n", "\n", @@ -311,52 +304,78 @@ }, { "cell_type": "markdown", - "id": "18848ac3", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "897482af", + "id": "b615bdfb", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "clang: fatal error: cannot find libdevice for sm_35. Provide path to different CUDA installation via --cuda-path, or pass -nocudalib to build without linking with libdevice.\n", - "[Native kernel] clang exited with code 1, the executable will not be executed" - ] - } - ], - "source": [] + "source": [ + "The corresponding Fortran program is shown below." + ] }, { "cell_type": "code", - "execution_count": 19, - "id": "315a724a", + "execution_count": 66, + "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpwit3re_h.c:16:5: error: orphaned 'omp teams' directives are prohibited; perhaps you forget to enclose the directive into a target region?\n", - " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", - " ^\n", - "1 error generated.\n", - "[Native kernel] clang exited with code 1, the executable will not be executed" + " 0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000" ] } ], - "source": [] - }, - { - "cell_type": "markdown", - "id": "b615bdfb", - "metadata": {}, - "source": [] + "source": [ + "!!%compiler: gfortran\n", + "!!%cflags: -fopenmp\n", + "\n", + " SUBROUTINE SUBDOMAIN(X, ISTART, IPOINTS)\n", + " INTEGER ISTART, IPOINTS\n", + " REAL X(0:99)\n", + "\n", + " INTEGER I\n", + "\n", + " DO 100 I=0,IPOINTS-1\n", + " X(ISTART+I) = ISTART+I\n", + "100 CONTINUE\n", + "\n", + " END SUBROUTINE SUBDOMAIN\n", + "\n", + " SUBROUTINE SUB(X, NPOINTS)\n", + " INCLUDE \"omp_lib.h\" ! or USE OMP_LIB\n", + "\n", + " REAL X(0:99)\n", + " INTEGER NPOINTS\n", + " INTEGER IAM, NT, IPOINTS, ISTART\n", + "\n", + "!$OMP PARALLEL DEFAULT(PRIVATE) SHARED(X,NPOINTS)\n", + "\n", + " IAM = OMP_GET_THREAD_NUM()\n", + " NT = OMP_GET_NUM_THREADS()\n", + " IPOINTS = NPOINTS/NT\n", + " ISTART = IAM * IPOINTS\n", + " IF (IAM .EQ. NT-1) THEN\n", + " IPOINTS = NPOINTS - ISTART\n", + " ENDIF\n", + " CALL SUBDOMAIN(X,ISTART,IPOINTS)\n", + "\n", + "!$OMP END PARALLEL\n", + " END SUBROUTINE SUB\n", + " \n", + " SUBROUTINE print(X, NPOINTS)\n", + " INTEGER I\n", + " REAL X(0:99)\n", + " INTEGER NPOINTS\n", + " DO I = 0,NPOINTS-1\n", + " WRITE(*,'(1x,f9.5,$)') X(I)\n", + " END DO\n", + " END SUBROUTINE PRINT\n", + "\n", + " PROGRAM PAREXAMPLE\n", + " REAL ARRAY(100)\n", + " CALL SUB(ARRAY, 100)\n", + " CALL PRINT(ARRAY, 100)\n", + " END PROGRAM PAREXAMPLE" + ] }, { "cell_type": "markdown", diff --git a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb index b0602b5..59d5b76 100644 --- a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb +++ b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 1, "id": "315a724a", "metadata": {}, "outputs": [ @@ -97,11 +97,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/tmpwit3re_h.c:16:5: error: orphaned 'omp teams' directives are prohibited; perhaps you forget to enclose the directive into a target region?\n", - " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", - " ^\n", - "1 error generated.\n", - "[Native kernel] clang exited with code 1, the executable will not be executed" + "OMP: Warning #96: Cannot form a team with 12 threads, using 6 instead.\n", + "OMP: Hint Consider unsetting KMP_DEVICE_THREAD_LIMIT (KMP_ALL_THREADS), KMP_TEAMS_THREAD_LIMIT, and OMP_THREAD_LIMIT (if any are set).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i=999 sp|dp 999.000000 999.000010 \n", + "i=500 sp|dp 500.000000 500.000005 \n" ] } ], From 27d98f156fb8874d2b78377d4b5cfe5cd9418986 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 31 Aug 2022 09:29:44 -0400 Subject: [PATCH 31/91] Fix the errors in C and Fortran program in 2_UsingOpenMP_parallel.ipynb Now they have exactly same meaning and output --- .../2_UsingOpenMP_parallel.ipynb | 33 ++++++++++++++++--- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 12663f0..1706cf6 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 83, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -238,7 +238,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000 " + "\n", + "0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 \n", + "10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 \n", + "20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 \n", + "30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 \n", + "40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 \n", + "50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 \n", + "60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 \n", + "70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 \n", + "80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 \n", + "90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000 " ] } ], @@ -273,6 +283,8 @@ "\n", "void print(float *x, int npoints) {\n", " for (int i = 0; i < npoints; i++) {\n", + " if(i % 10 == 0)\n", + " printf(\"\\n\");\n", " printf(\"%.5f \", x[i]);\n", " }\n", "}\n", @@ -312,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 81, "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ @@ -320,7 +332,17 @@ "name": "stdout", "output_type": "stream", "text": [ - " 0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000" + " \n", + " 0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 \n", + " 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 \n", + " 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 \n", + " 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 \n", + " 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 \n", + " 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 \n", + " 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 \n", + " 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 \n", + " 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 \n", + " 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000" ] } ], @@ -366,6 +388,9 @@ " REAL X(0:99)\n", " INTEGER NPOINTS\n", " DO I = 0,NPOINTS-1\n", + " IF (mod(I,10) .EQ. 0) THEN\n", + " print*,' '\n", + " END IF\n", " WRITE(*,'(1x,f9.5,$)') X(I)\n", " END DO\n", " END SUBROUTINE PRINT\n", From bff56b40c2bd663941fcb2aa72aeab297c5f6397 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 31 Aug 2022 09:39:10 -0400 Subject: [PATCH 32/91] Generate the output for one fortran example --- .../2_UsingOpenMP_parallel.ipynb | 31 +++++++++++++++---- 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 1706cf6..5fec868 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -87,10 +87,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3cf85b73", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "Hello World\n", + "Hello World\n", + "Hello World\n" + ] + } + ], "source": [ "//%compiler: clang\n", "//%cflags: -fopenmp\n", @@ -139,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "29b05917", "metadata": {}, "outputs": [ @@ -180,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "id": "eb7e4cbd", "metadata": {}, "outputs": [ @@ -230,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 5, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -324,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 6, "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ @@ -429,6 +440,14 @@ "source": [ "## Examples" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78bd8594-76fd-4fd6-b6db-e2b9a702229d", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From d48b16398e89baa5783998cb097b72d3e2498c50 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Thu, 8 Sep 2022 01:28:39 -0400 Subject: [PATCH 33/91] Added some description of clauses. Not finished --- .../2_UsingOpenMP_parallel.ipynb | 198 +++++++++++++----- 1 file changed, 140 insertions(+), 58 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 5fec868..6f023fc 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -21,9 +21,8 @@ "id": "89d198a4", "metadata": {}, "source": [ - "## Semantics and Syntax\n", + "## Get Started with **Parallel** Directive to Create Parallelism\n", "\n", - "### **parallel** Directive\n", "The **parallel** directive is used to mark a parallel region. When a thread encounters a parallel region, a group of threads is created to execute the parallel region.\n", "The original thread that executed the serial part will be the primary thread of the new team. All threads in the team execute parallel regions together. After a team is created, the number of threads in the team remains constant for the duration of that parallel region.\n", "\n", @@ -37,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "e14d751a", "metadata": {}, "outputs": [ @@ -81,13 +80,13 @@ "id": "7332a65a", "metadata": {}, "source": [ - "This example prints *Hello World* 8 times, which means 8 threads are created by defualt. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", + "This example prints *Hello World* 8 times, which means 8 threads are created by default. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", "The following example shows how to use the num_threads clause in the parallel directive to specify the number of threads to create." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "3cf85b73", "metadata": {}, "outputs": [ @@ -124,20 +123,7 @@ "metadata": {}, "source": [ "In this example, we use the **num_threads** clause to specify the use of 4 threads to execute the parallel region. When the master thread encounters OpenMP constructs, three threads are created, and together with these three threads, a thread group of 4 is formed. \n", - "*Hello World* is printed four times, once per thread.\n", - "\n", - "Through the above examples, it is not difficult to find that the syntax of parallel directive in C is:\n", - "\n", - "```\n", - "#pragma omp parallel [clause[ [,] clause] ... ] new-line\n", - " structured-block\n", - "```\n", - "\n", - "And the syntax of **num_threads** clause is：\n", - "\n", - "```\n", - "num_threads(integer-expression)\n", - "```" + "*Hello World* is printed four times, once per thread." ] }, { @@ -145,12 +131,12 @@ "id": "0b8fbc89", "metadata": {}, "source": [ - "The next two examples show how to use **paralle** diretcive in Fortran, and they have exactly same meaning as the two examples in C above." + "The next two examples show how to use the **parallel** directive in Fortran, and they have the exactly same meaning as the two examples in C above." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "29b05917", "metadata": {}, "outputs": [ @@ -191,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "eb7e4cbd", "metadata": {}, "outputs": [ @@ -222,26 +208,149 @@ "END" ] }, + { + "cell_type": "markdown", + "id": "d0629b36", + "metadata": {}, + "source": [ + "## Syntax and Semantics of **Parallel** Directive and Its Clauses" + ] + }, + { + "cell_type": "markdown", + "id": "1fc04bb4", + "metadata": {}, + "source": [ + "Through the examples shown in the last section, it is not difficult to conclude that the syntax of the **parallel** directive in C is:\n", + "\n", + "```\n", + "#pragma omp parallel [clause[ [,] clause] ... ] new-line\n", + " structured-block\n", + "```" + ] + }, { "cell_type": "markdown", "id": "b39385c2", "metadata": {}, "source": [ - "The syntax of **parallel** directive in Fortran is:\n", + "The syntax of the **parallel** directive in Fortran is:\n", "```\n", "!$omp parallel do [clause[ [,] clause] ... ]\n", " loop-nest\n", "[!$omp end parallel do]\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "a28e7125-2728-416d-88fa-b6257e900194", + "metadata": {}, + "source": [ + "We used the *num_threads* clause in the above example to indicate the number of threads used to execute parallel regions. As we have already introduced in chapter 1, clauses are used to specify additional information with the directive.\n", + "Ten clauses can be used with the **parallel** directive, which are if, num_threads, default, private, firstprivate, shared, copyin, reduction, proc_bind and allocate.\n", + "\n", + "```\n", + "if([ parallel :] scalar-expression)\n", + "num_threads(integer-expression)\n", + "default(data-sharing-attribute)\n", + "private(list)\n", + "firstprivate(list)\n", + "shared(list)\n", + "copyin(list)\n", + "reduction([reduction-modifier ,] reduction-identifier : list)\n", + "proc_bind(affinity-policy)\n", + "allocate([allocator :] list)\n", + "```\n", + "\n", + "### if clause\n", + "*if* clause can achieve conditional parallelism, it can be used with many directives, such as **parallel**, **task**, **simd**, etc., its effect depends on the construct to which it is applied . Its syntax is as follows:\n", + "```\n", + "if([ directive-name-modifier :] scalar-expression)\n", + "```\n", + "or\n", + "```\n", + "if([ directive-name-modifier :] scalar-logical-expression)\n", + "```\n", + "\n", + "The directive-name-modifier is optional and is very useful in combined constructs, which we will cover later. When the if claue is used with the parallel directive, only parallel can be used as the directive-name-modifier. Its semantics are that the parallel region is active when the scaler-expression or scalar-logical-expression is true, otherwise the parallel region that follows will be inactive.\n", + "\n", + "### num_threads clause\n", + "The syntax for *num_threads* is as follows:\n", + "```\n", + "num_threads(integer-expression)\n", + "```\n", + "\n", + "It is used to explicitly set the number of threads used by the parallel region. The number of threads in the parallel region is determined by integer-expression.\n", + "\n", + "### Data-Sharing Attribute Clauses\n", + "There are four Data-Sharing Attribute Clauses that can be used with the parallel directive, namely default clause, private clause, firstprivate clause and shared clause. Data-Sharing Attribute Clauses are used to control the data-sharing attributes of variables.\n", + "\n", + "We first introduce the private clause, firstprivate clause and shared clause, which represent three data-sharing attributes of the variables respectively.\n", + "\n", + "#### private clause\n", + "\n", + "#### default clause\n", + "The syntax of *default* clause：\n", "```\n", + "default(data-sharing-attribute)\n", + "```\n", + "\n", + "The default clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task-generating construct. \n", + "The data-sharing-attribute is one of the following:\n", + "\n", + "> shared
    \n", + "> firstprivate
    \n", + "> private
    \n", + "> none\n", + "\n", "\n", + "#### private clause\n" + ] + }, + { + "cell_type": "markdown", + "id": "c6acb505-4e89-4e93-9f5e-9034ead13466", + "metadata": {}, + "source": [ + "## More Advanced Examples of Using Other Clauses and the Analysis of Performance and Improvement" + ] + }, + { + "cell_type": "markdown", + "id": "159a781e-eeeb-44a6-bc33-4b5e95d0d9df", + "metadata": {}, + "source": [ + "## *if* clause\n", + "*if* clause可以实现有条件的并行，它可以跟很多directives一起使用，例如**parallel**，**task**， **simd**等，，我们会在后面的章节中慢慢介绍，在此我们介绍当\n", + "\n", + "//在CPU上，决定性能的因素有很多，回忆在上个章节中提到的能够改善性能的因素，\n", + "- Thread load balancing\n", + "- Minimizing synchronization.\n", + "- Using more efficient directives. For example, using PARALLEL DO/FOR instead of worksharing DO/FOR directives in parallel regions.\n", + "- Expansion or merging of parallel regions\n", + "- Improving cache hit rate\n", + "- Optimization of round-robin scheduling\n", + "- Variable property optimization\n", + "- Optimization to reduce false sharing problem\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "35f744ac-de70-4c5d-a577-c04cee3fdff3", + "metadata": {}, + "source": [ "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the **omp_get_thread_num** library routine.\n", "\n", - "The following example is a little more complicated. It shows how to use the **omp_get_thread_num** library routine, and shows how to use two other clauses, the **default** clause and the **private** clause. It assigns tasks to each thread explicitly." + "The following example is a little more complicated. It shows how to use the **omp_get_thread_num** library routine and shows how to use two other clauses, the **default** clause and the **private** clause. It assigns tasks to each thread explicitly." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -310,7 +419,7 @@ }, { "cell_type": "markdown", - "id": "20db34ef", + "id": "f03e7f59-b091-44f0-aee1-b8242d0adeb1", "metadata": {}, "source": [ "In the above example, we use the default number of threads to perform assignment operations on 100 elements in the array. Tasks are evenly distributed to each thread, and when the number of tasks is not divisible by the number of threads, the remaining tasks will be completed by the last thread.\n", @@ -319,7 +428,7 @@ "\n", "In the above example, variable *npoints* presents the total number of elements in the array, and it is divided into *nt* parts, each of size *ipoints*. The starting address of each part is *istart*. Each part is completed by one thread, and a total of 8 threads execute tasks in parallel.\n", "\n", - "The **default** clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task generating construct. In the above example, *default(shared)* indicates that by default, the variables in the parallel region are shared variables.\n", + "The **default** clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task-generating construct. In the above example, *default(shared)* indicates that by default, the variables in the parallel region are shared variables.\n", "The **private** clause is used to explicitly specify variables that are private in each task or SIMD lane (SIMD will be introduced in the next chapter). In the above example, the variables *iam, nt, ipoints* and *istart* are private variables for each thread, which means a thread cannot access these variables of another thread.\n", "\n", "Both of these two clauses belong to the data-sharing attribute clauses, which we will introduce in detail in the section of clauses later." @@ -327,7 +436,7 @@ }, { "cell_type": "markdown", - "id": "b615bdfb", + "id": "5671bb98-a6b5-41e8-9315-288bcc73aeda", "metadata": {}, "source": [ "The corresponding Fortran program is shown below." @@ -335,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ @@ -413,34 +522,6 @@ " END PROGRAM PAREXAMPLE" ] }, - { - "cell_type": "markdown", - "id": "d0629b36", - "metadata": {}, - "source": [ - "## Clauses" - ] - }, - { - "cell_type": "markdown", - "id": "1fc04bb4", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "id": "e16a6d8d", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "id": "a252f343", - "metadata": {}, - "source": [ - "## Examples" - ] - }, { "cell_type": "code", "execution_count": null, @@ -460,7 +541,8 @@ "file_extension": ".c", "mimetype": "text/plain", "name": "c" - } + }, + "toc-showcode": false }, "nbformat": 4, "nbformat_minor": 5 From 3fc193bbd3d3cf99c15c94d0e955edfa0c951bab Mon Sep 17 00:00:00 2001 From: xinyao Date: Thu, 8 Sep 2022 15:40:56 -0400 Subject: [PATCH 34/91] Added some content for section 2.2. Unfinished --- .../2_UsingOpenMP_parallel.ipynb | 120 +++++++++++------- 1 file changed, 75 insertions(+), 45 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 6f023fc..716eaad 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "e14d751a", "metadata": {}, "outputs": [ @@ -51,10 +51,6 @@ "Hello World\n", "Hello World\n", "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", - "Hello World\n", "Hello World\n" ] } @@ -81,12 +77,12 @@ "metadata": {}, "source": [ "This example prints *Hello World* 8 times, which means 8 threads are created by default. The default number of threads is determined by the computer hardware, 8 threads are created on the author's computer. \n", - "The following example shows how to use the num_threads clause in the parallel directive to specify the number of threads to create." + "The following example shows how to use the **num_threads** clause in the parallel directive to specify the number of threads to create." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "3cf85b73", "metadata": {}, "outputs": [ @@ -136,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "29b05917", "metadata": {}, "outputs": [ @@ -151,10 +147,6 @@ " Hello World\n", " Hello World\n", " Hello World\n", - " Hello World\n", - " Hello World\n", - " Hello World\n", - " Hello World\n", " Hello World\n" ] } @@ -177,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "eb7e4cbd", "metadata": {}, "outputs": [ @@ -247,8 +239,8 @@ "id": "a28e7125-2728-416d-88fa-b6257e900194", "metadata": {}, "source": [ - "We used the *num_threads* clause in the above example to indicate the number of threads used to execute parallel regions. As we have already introduced in chapter 1, clauses are used to specify additional information with the directive.\n", - "Ten clauses can be used with the **parallel** directive, which are if, num_threads, default, private, firstprivate, shared, copyin, reduction, proc_bind and allocate.\n", + "We used the **num_threads** clause in the previous example to indicate the number of threads used to execute parallel regions. As we have already introduced in chapter 1, clauses are used to specify additional information with the directive.\n", + "Ten clauses can be used with the **parallel** directive, listing as follows:\n", "\n", "```\n", "if([ parallel :] scalar-expression)\n", @@ -263,8 +255,8 @@ "allocate([allocator :] list)\n", "```\n", "\n", - "### if clause\n", - "*if* clause can achieve conditional parallelism, it can be used with many directives, such as **parallel**, **task**, **simd**, etc., its effect depends on the construct to which it is applied . Its syntax is as follows:\n", + "### **if** Clause\n", + "The **if** clause is used to achieve conditional parallelism. It can be used with many directives, such as **parallel** directive, **task** directive, **simd** directive, etc. Its effect depends on the construct to which it is applied. The syntax is as follows:\n", "```\n", "if([ directive-name-modifier :] scalar-expression)\n", "```\n", @@ -273,39 +265,87 @@ "if([ directive-name-modifier :] scalar-logical-expression)\n", "```\n", "\n", - "The directive-name-modifier is optional and is very useful in combined constructs, which we will cover later. When the if claue is used with the parallel directive, only parallel can be used as the directive-name-modifier. Its semantics are that the parallel region is active when the scaler-expression or scalar-logical-expression is true, otherwise the parallel region that follows will be inactive.\n", + "The *directive-name-modifier* is optional and is very useful in combined constructs, which we will cover in the later chapters. When the **if** claue is used with the **parallel** directive, only *parallel* can be used as the *directive-name-modifier*. Its semantics are that the parallel region is active when the *scaler-expression* or *scalar-logical-expression* is true, otherwise the parallel region that follows will be inactive. At most one **if** clause can be used in each parallel construct.\n", "\n", - "### num_threads clause\n", - "The syntax for *num_threads* is as follows:\n", + "### **num_threads** Clause\n", + "The syntax for **num_threads** is as follows:\n", "```\n", "num_threads(integer-expression)\n", "```\n", "\n", - "It is used to explicitly set the number of threads used by the parallel region. The number of threads in the parallel region is determined by integer-expression.\n", + "It is used to explicitly set the number of threads used by the parallel region. The number of threads in the parallel region is determined by *integer-expression*. At most one **num_threads** clause can be used in each parallel construct. Because the number of threads used must be uniquely determined when entering the parallel region， whether explicitly specified by the programmer using **num_threads** clause or implicitly specified by the compiler. Of course, the *scaler-expression* must be an integer greater than zero.\n", "\n", "### Data-Sharing Attribute Clauses\n", - "There are four Data-Sharing Attribute Clauses that can be used with the parallel directive, namely default clause, private clause, firstprivate clause and shared clause. Data-Sharing Attribute Clauses are used to control the data-sharing attributes of variables.\n", + "Data-sharing attribute clauses are used to control the data-sharing attributes of variables.\n", + "\n", + "There are four data-sharing attribute clauses that can be used with the **parallel** directive, namely **default** clause, **private** clause, **firstprivate** clause and **shared** clause. The **lastprivate** clause and **linear** clause are two other data-sharing attribute clauses. They cannot be used with **parallel** directives, so we will skip them for now and describe them in detail in later chapters.\n", + "\n", + "We first introduce the **private** clause, **firstprivate** clause and **shared** clause.\n", + "\n", + "#### **private** Clause\n", + "\n", + "The syntax of the **private** clause is as follows:\n", + "\n", + "```\n", + "private(list)\n", + "```\n", + "\n", + "As mentioned before, a set of implicit tasks, equal in number to the number of threads in the team, is generated by the master thread when it encountering the parallel region.\n", + "The **private** caluse is used to declare private variable(s) in the *list* for a task or a SIMD lane. A private variable has a different address in the execution context of every thread. These variables are private to threads, and threads cannot access private variables owned by other threads. Programmers can use the **private** clause as many times as needed.\n", + "\n", + "#### **firstprivate** Clause\n", + "The **firstprivate** clause is very similar to the **private** clause. They both indicate that the variables in the *list* are private to the thread. Its syntax is as follows:\n", + "\n", + "```\n", + "firstprivate(list)\n", + "```\n", + "\n", + "But unlike the **private** clause, the variables in the *list* are initialized to the initial value that the original item had in the serial area. Like **private** clause, the **firstprivate** clause can be used multiple times in the parallel construct.\n", "\n", - "We first introduce the private clause, firstprivate clause and shared clause, which represent three data-sharing attributes of the variables respectively.\n", + "#### **shared** Clause\n", "\n", - "#### private clause\n", + "The **shared** clause is used to declare that one or more items in the *list* can be shared by tasks or SIMD lane. Its syntax is as follows:\n", + "\n", + "```\n", + "shared(list)\n", + "```\n", + "\n", + "Shared variables have the same address in the execution context of every thread. In a parallel region, all threads or SIMD lanes can access these variables. The **shared** clause can also be used multiple times within a parallel struct.\n", + "\n", + "#### **default** Clause\n", + "\n", + "The syntax of **default** clause：\n", "\n", - "#### default clause\n", - "The syntax of *default* clause：\n", "```\n", "default(data-sharing-attribute)\n", "```\n", "\n", - "The default clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task-generating construct. \n", - "The data-sharing-attribute is one of the following:\n", + "The **default** clause is used to define the default data-sharing attribute of variables in a parallel construct(it also can be used in a teams, or task-generating construct). \n", + "The *data-sharing-attribute* is one of the following:\n", "\n", - "> shared
    \n", - "> firstprivate
    \n", "> private
    \n", + "> firstprivate
    \n", + "> shared
    \n", "> none\n", "\n", + "When the data-sharing attribute of a variable is not specified, the data-sharing attribute of this variable will be set to the attribute specified in the **default** clause. If we have a variable *a* and the *data-sharing-attribute* in the **default** clause is *shared*, then we can understand it like this:\n", + "\n", + "> if(variable *a* is not assigned data-sharing attribute && we have clause **default(shared)**) {
    \n", + " equals to : we have clause **shared(a)**
    \n", + "> }\n", + "\n", + "A special note for the **default(none)** clause:\n", + "\n", + "> The **default(none)** clause means that we do not define any data-sharing attribute for variables. The compiler does not implicitly define this for us, therefore, the variables need to be listed explicitly in other data-sharing attribute clauses.\n", + "\n", + "Unlike the above three clauses, **default** clause can only appear once in a directive. \n", + "\n", "\n", - "#### private clause\n" + "#### Implicit Scoping Rules\n", + "\n", + "You may ask, if the **default** clause is not used, what data-sharing attribute is the variable that is not explicitly listed in other clauses? In fact, OpenMP defines a set of implicit scope rules. It determines the data-sharing attribute of a variable based on the characteristics of the variable being accessed. For example, for threads in a group, a variable is scoped to *shared* if using this variable in the parallel region does not result in a data race condition. A variable is scoped to *private* if, in each thread executing the parallel region, the variable is always written before being read by the same thread. The detailed rules can be found in the OpenMP specification.\n", + "\n", + "Although OpenMP proposes as detailed and explicit rules as possible for implicit scoping, there is still a high possibility of unpredictable errors. Therefore, it is undoubtedly the best choice for programmers to use clauses to explicitly specify the data-sharing attributes of variables. This is an important aspect of OpenMP program optimization." ] }, { @@ -322,7 +362,7 @@ "metadata": {}, "source": [ "## *if* clause\n", - "*if* clause可以实现有条件的并行，它可以跟很多directives一起使用，例如**parallel**，**task**， **simd**等，，我们会在后面的章节中慢慢介绍，在此我们介绍当\n", + "\n", "\n", "//在CPU上，决定性能的因素有很多，回忆在上个章节中提到的能够改善性能的因素，\n", "- Thread load balancing\n", @@ -350,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -444,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ @@ -452,17 +492,7 @@ "name": "stdout", "output_type": "stream", "text": [ - " \n", - " 0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 \n", - " 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 \n", - " 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 \n", - " 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 \n", - " 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 \n", - " 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 \n", - " 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 \n", - " 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 \n", - " 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 \n", - " 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000" + " \n" ] } ], From 57f72cb47dc317d39c90f9f6a5bdcfc40841b3d6 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Thu, 8 Sep 2022 18:25:20 -0400 Subject: [PATCH 35/91] Added description for copyin clause --- .../2_UsingOpenMP_parallel.ipynb | 33 +++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 716eaad..fa17873 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -239,7 +239,7 @@ "id": "a28e7125-2728-416d-88fa-b6257e900194", "metadata": {}, "source": [ - "We used the **num_threads** clause in the previous example to indicate the number of threads used to execute parallel regions. As we have already introduced in chapter 1, clauses are used to specify additional information with the directive.\n", + "As we have already introduced in chapter 1, clauses are used to specify additional information with the directive.\n", "Ten clauses can be used with the **parallel** directive, listing as follows:\n", "\n", "```\n", @@ -273,7 +273,8 @@ "num_threads(integer-expression)\n", "```\n", "\n", - "It is used to explicitly set the number of threads used by the parallel region. The number of threads in the parallel region is determined by *integer-expression*. At most one **num_threads** clause can be used in each parallel construct. Because the number of threads used must be uniquely determined when entering the parallel region， whether explicitly specified by the programmer using **num_threads** clause or implicitly specified by the compiler. Of course, the *scaler-expression* must be an integer greater than zero.\n", + "We used the **num_threads** clause in the previous example to indicate the number of threads used to execute parallel regions. \n", + "The number of threads in the parallel region is determined by *integer-expression*. At most one **num_threads** clause can be used in each parallel construct. Because the number of threads used must be uniquely determined when entering the parallel region， whether explicitly specified by the programmer using **num_threads** clause or implicitly specified by the compiler. Of course, the *scaler-expression* must be an integer greater than zero.\n", "\n", "### Data-Sharing Attribute Clauses\n", "Data-sharing attribute clauses are used to control the data-sharing attributes of variables.\n", @@ -348,6 +349,34 @@ "Although OpenMP proposes as detailed and explicit rules as possible for implicit scoping, there is still a high possibility of unpredictable errors. Therefore, it is undoubtedly the best choice for programmers to use clauses to explicitly specify the data-sharing attributes of variables. This is an important aspect of OpenMP program optimization." ] }, + { + "cell_type": "markdown", + "id": "bbb0b499-66b1-4d59-a11f-e449b5cb9062", + "metadata": {}, + "source": [ + "### **copyin** Clause\n", + "\n", + "The **copyin** clause is the one of two data copying clauses that can be used on the **parallel** construct or combined parallel worksharing constructs. The other one is the **copyprivate** clause which is only allowed on the **single** construct.\n", + "\n", + "\n", + "Before introducing these two clauses, we need to introduce a new data-sharing attribute, named *threadprivate*. The difference between private variables and thread private variables can be briefly described as follows:\n", + "- Private variables are local to a region and are placed on the stack most of the time. The lifetime of a private variable is the duration defined by the data scope clause. Every thread, including the main thread, makes a private copy of the original variable, and the new variable is no longer storage-associated to the original.\n", + "- Threadprivate variables are persist across regions, most likely to be placed in the heap or in thread-local storage, which can be seen as being stored in a local memory local to the thread. The main thread uses the original variable and other threads make private copies of the original variable. The host variable is still store-associated with the original variable.\n", + "\n", + "The syntax of the **copyin** Clause is as follows:\n", + "```\n", + "copyin(list)\n", + "```\n", + "\n", + "It can copy the value of the main thread's threadprivate variable into the threadprivate variable of every other member in the team that is executing the parallel region.\n", + "\n", + "### **reduction** Clause\n", + "\n", + "\n", + "### **proc_bind** Clause\n", + "### **allocate** Clause" + ] + }, { "cell_type": "markdown", "id": "c6acb505-4e89-4e93-9f5e-9034ead13466", From 8dfb2a8727147dd1ac941de8adf3c865f51ae5c5 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 20 Sep 2022 11:41:24 -0400 Subject: [PATCH 36/91] Added the description of reduction clause --- .../2_UsingOpenMP_parallel.ipynb | 79 +++++++++++++++++-- 1 file changed, 71 insertions(+), 8 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index fa17873..8e8b7aa 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -346,14 +346,8 @@ "\n", "You may ask, if the **default** clause is not used, what data-sharing attribute is the variable that is not explicitly listed in other clauses? In fact, OpenMP defines a set of implicit scope rules. It determines the data-sharing attribute of a variable based on the characteristics of the variable being accessed. For example, for threads in a group, a variable is scoped to *shared* if using this variable in the parallel region does not result in a data race condition. A variable is scoped to *private* if, in each thread executing the parallel region, the variable is always written before being read by the same thread. The detailed rules can be found in the OpenMP specification.\n", "\n", - "Although OpenMP proposes as detailed and explicit rules as possible for implicit scoping, there is still a high possibility of unpredictable errors. Therefore, it is undoubtedly the best choice for programmers to use clauses to explicitly specify the data-sharing attributes of variables. This is an important aspect of OpenMP program optimization." - ] - }, - { - "cell_type": "markdown", - "id": "bbb0b499-66b1-4d59-a11f-e449b5cb9062", - "metadata": {}, - "source": [ + "Although OpenMP proposes as detailed and explicit rules as possible for implicit scoping, there is still a high possibility of unpredictable errors. Therefore, it is undoubtedly the best choice for programmers to use clauses to explicitly specify the data-sharing attributes of variables. This is an important aspect of OpenMP program optimization.\n", + "\n", "### **copyin** Clause\n", "\n", "The **copyin** clause is the one of two data copying clauses that can be used on the **parallel** construct or combined parallel worksharing constructs. The other one is the **copyprivate** clause which is only allowed on the **single** construct.\n", @@ -372,11 +366,80 @@ "\n", "### **reduction** Clause\n", "\n", + "The **reduction** clause belongs to the *reduction scoping clauses* and the *reduction participating clauses*. The *reduction scoping clauses* define the region of a reduction computed by a task or a SIMD lane. The *reduction participating clauses* are used to define a task or SIMD channel as a reduction participant. The **reduction** clause is specifically designed for reduction operations, and it allows the user to specify one or more thread-private variables that accept reduction operation at the end of the parallel region.\n", + "\n", + "The syntax of the **reduction** clause is as follows:\n", + "```\n", + "reduction([ reduction-modifier,]reduction-identifier : list)\n", + "```\n", + "\n", + "The *reduction-modifier* is optional and is used to describe the characteristics of the reduction operation. It can be one of the following:\n", + "> inscan
    \n", + "> task
    \n", + "> default\n", + "\n", + "When the *reduction-modifier* is *inscan*, the list items on each iteration of a loop nest will be updated with scan computation.\n", + "When *inscan* is used, one list item must be as a list item in an **inclusive** or **exclusive** clause on a **scan** directive enclosed by the construct. \n", + "It separates the items in the list from the reduction operations, and decides whether the storage statement includes or excludes the scan input of the present iteration.\n", + "\n", + "When the *reduction-modifier* is *task*, an indeterminate number of additional private copies will be generated to support task reduction, and these reduction-related copies will be initialized before they are accessed by the tasks.\n", + "\n", + "When *reduction-modifier* is *default* or when no *reduction-modifier* is specified, the behavior will be relative to the construct in which the reduction is located. For **parallel**, **scope** and **simd** construcrs, one or more private copies of each list item are created for each implicit task (for **parallel** and **scope**) or SIMD lane (for **simd**), as if the **private** clause had been used. Some other rules for other constructs can be found in the OpenMP specification and we will not go into details here.\n", + "\n", + "The *reduction-identifier* is used to specify the reduction operator.\n", + "According to the OpenMP specification, the *reduction-identifier* has the following syntax:\n", + "\n", + "> - For C language，a *reduction-identifier* is either an identifier or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||.\n", + "> - For C++, a *reduction-identifier* is either an id-expression or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||.\n", + "> - For Fortran， a *reduction-identifier* is either a base language identifier, or a user-defined operator, or one of the following operators: +, - (deprecated), \\*, .and., .or., .eqv., .neqv., or one of the following intrinsic procedure names: max, min, iand, ior, ieor.\n", + "\n", + "The following two tables, also from the OpenMP specification, show implicitly declared reduction-identifiers for numeric and logical types, including the initial value settings, and semantics for the reduction-identifiers.\n", + "\n", + "For C/C++:\n", + "\n", + "|Identifier |Initializer |Combiner |\n", + "|--------------|--------------------------------------------------------------------------|------------------------------------------------|\n", + "|+ |omp_priv = 0 |omp_out += omp_in |\n", + "|- |omp_priv = 0 |omp_out += omp_in |\n", + "|* |omp_priv = 1 |omp_out \\*= omp_in |\n", + "|& |omp_priv = ~ 0 |omp_out &= omp_in |\n", + "|\\| |omp_priv = 0 |omp_out \\|= omp_in |\n", + "|^ |omp_priv = 0 |omp_out ^= omp_in |\n", + "|&& |omp_priv = 1 |omp_out = omp_in && omp_out |\n", + "| \\|\\| |omp_priv = 0 |omp_out = omp_in || omp_out |\n", + "|max |omp_priv = Minimal representable number in the reduction list item type |omp_out = omp_in > omp_out ? omp_in : omp_out |\n", + "|min |omp_priv = Maximal representable number in the reduction list item type |omp_out = omp_in < omp_out ? omp_in : omp_out |\n", + " \n", + "\n", + "For Fortran：\n", + "\n", + "|Identifier |Initializer |Combiner |\n", + "|--------------|---------------------------------------------------------------------------|----------------------------------|\n", + "|+ |omp_priv = 0 |omp_out = omp_in + omp_out |\n", + "|- |omp_priv = 0 |omp_out = omp_in + omp_out |\n", + "|\\* |omp_priv = 1 |omp_out = omp_in \\* omp_out |\n", + "|.and. |omp_priv = .true. |omp_out = omp_in .and. omp_out | \n", + "|.or. |omp_priv = .false. |omp_out = omp_in .or. omp_out |\n", + "|.eqv. |omp_priv = .true. |omp_out = omp_in .eqv. omp_out |\n", + "|.neqv. |omp_priv = .false. |omp_out = omp_in .neqv. omp_out |\n", + "|max |omp_priv = Minimal representable number in the reduction list item type |omp_out = max(omp_in, omp_out) |\n", + "|min |omp_priv = Maximal representable number in the reduction list item type |omp_out = min(omp_in, omp_out) |\n", + "|iand |omp_priv = All bits on |omp_out = iand(omp_in, omp_out) |\n", + "|ior |omp_priv = 0 |omp_out = ior(omp_in, omp_out) |\n", + "|ieor |omp_priv = 0 |omp_out = ieor(omp_in, omp_out) |\n", "\n", "### **proc_bind** Clause\n", + "\n", + "\n", "### **allocate** Clause" ] }, + { + "cell_type": "markdown", + "id": "bbb0b499-66b1-4d59-a11f-e449b5cb9062", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "id": "c6acb505-4e89-4e93-9f5e-9034ead13466", From 12fbf422bb030130d35f3c1ec7543b00ddb71f55 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 20 Sep 2022 12:05:43 -0400 Subject: [PATCH 37/91] Fixed one small error --- src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 8e8b7aa..91c3653 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -331,9 +331,11 @@ "\n", "When the data-sharing attribute of a variable is not specified, the data-sharing attribute of this variable will be set to the attribute specified in the **default** clause. If we have a variable *a* and the *data-sharing-attribute* in the **default** clause is *shared*, then we can understand it like this:\n", "\n", - "> if(variable *a* is not assigned data-sharing attribute && we have clause **default(shared)**) {
    \n", - " equals to : we have clause **shared(a)**
    \n", - "> }\n", + "```\n", + "if(variable a is not assigned data-sharing attribute && we have clause default(shared)) {\n", + " equals to : we have clause shared(a)\n", + "}\n", + "```\n", "\n", "A special note for the **default(none)** clause:\n", "\n", From 51481e94496eaa5c282c1b725394a56c2580b091 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 20 Sep 2022 12:14:20 -0400 Subject: [PATCH 38/91] Formatting error --- src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 91c3653..e9d2ac7 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -391,9 +391,9 @@ "The *reduction-identifier* is used to specify the reduction operator.\n", "According to the OpenMP specification, the *reduction-identifier* has the following syntax:\n", "\n", - "> - For C language，a *reduction-identifier* is either an identifier or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||.\n", - "> - For C++, a *reduction-identifier* is either an id-expression or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||.\n", - "> - For Fortran， a *reduction-identifier* is either a base language identifier, or a user-defined operator, or one of the following operators: +, - (deprecated), \\*, .and., .or., .eqv., .neqv., or one of the following intrinsic procedure names: max, min, iand, ior, ieor.\n", + "- For C language，a *reduction-identifier* is either an identifier or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||. \n", + "- For C++, a *reduction-identifier* is either an id-expression or one of the following operators: +, - (deprecated), \\*, &, |, ^, && and ||. \n", + "- For Fortran， a *reduction-identifier* is either a base language identifier, or a user-defined operator, or one of the following operators: +, - (deprecated), \\*, .and., .or., .eqv., .neqv., or one of the following intrinsic procedure names: max, min, iand, ior, ieor.\n", "\n", "The following two tables, also from the OpenMP specification, show implicitly declared reduction-identifiers for numeric and logical types, including the initial value settings, and semantics for the reduction-identifiers.\n", "\n", From 4cc85ba6f6d6bf040d76d9ecbfbd5b1dfa506649 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 20 Sep 2022 18:02:42 -0400 Subject: [PATCH 39/91] Added description for proc_bind clause and allocate clause --- .../2_UsingOpenMP_parallel.ipynb | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index e9d2ac7..f5fde6b 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -432,8 +432,33 @@ "\n", "### **proc_bind** Clause\n", "\n", + "The **proc_bind** clause is used to specify a mapping of OpenMP threads to places within the current place partition for implicit tasks of the encountering threads. Its syntax is as follows:\n", + "```\n", + "proc_bind(affinity-policy) \n", + "```\n", + "and the *affinity-policy* is one of the following：\n", + "> primary
    \n", + "> master \\[deprecated\\]
    \n", + "> close
    \n", + "> spread\n", + "\n", + "When *affinity-policy* is specified as *primary*, it means that the execution environment assigns each thread in the group to the same location as the primary thread.\n", + "The *master* affinity policy has been deprecated, it has identical semantics as *prime*.\n", + "\n", + "The *close* thread affinity policy instructs the execution environment to assign threads in the group closer to the parent thread's location. When the number of threads **P** in the group is less than the number of locations **P** in the partition where the parent thread is located, each thread will be assigned one place, otherwise, **T/P** threads will be assigned to one place. When **P** does not divide **T** equally, the exact number of threads at a particular place is implementation-defined. The principle of allocation is that the thread number with the thread with the smallest thread number is executed at the position of the parent thread, and then the threads are allocated backward in the order of increasing thread number, and wrap-around with respect to the place partition of the primary thread. \n", + "\n", + "The *spread* thread affinity policy is to create **P** sub-partitions in the parent partition and distribute the threads in these sub-partitions, thus achieving a sparse distribution.\n", + "When the number of threads is equal to or less than **P**, the number of sub-partitions is equal to the number of threads **T**, and the threads are distributed in the first position of each partition in order of thread number from small to large. Conversely, when the number of threads is greater than **P**, **T/P** threads with consecutive thread numbers are allocated to each sub-partition. \n", + "Sorted by thread number, the first **T/P** threads are allocated in the subpartition that contains the place of the parent thread. The remaining thread groups are allocated backward in turn, with a wrap-around with respect to the original place partition of the primary thread.\n", + "\n", + "### **allocate** Clause\n", + "The **allocate** clause is used to specify the memory allocator used to obtain storage of the private variables. When it is used with **parallel** construct, the syntax is shown as following:\n", + "```\n", + "allocate([allocator:] list) \n", + "```\n", "\n", - "### **allocate** Clause" + "In C/C++, the *allocator* is an expression of the omp_allocator_handle_t type. In Fortran, the *allocator* is an integer expression of the omp_allocator_handle_kindkind. \n", + "We will not list these allocators here, readers can find them in the OpenMP specification, but we will explain some commonly used allocators in the examples in the following section." ] }, { From 5cf564a8bcfbc77fec9869857d87a5a84e7834c3 Mon Sep 17 00:00:00 2001 From: xinyao Date: Tue, 20 Sep 2022 22:04:56 -0400 Subject: [PATCH 40/91] Added the limitation of the new added clauses --- src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index f5fde6b..11dd6c4 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -364,7 +364,7 @@ "copyin(list)\n", "```\n", "\n", - "It can copy the value of the main thread's threadprivate variable into the threadprivate variable of every other member in the team that is executing the parallel region.\n", + "It can copy the value of the main thread's threadprivate variable into the threadprivate variable of every other member in the team that is executing the parallel region. And it can be used multiple times within a parallel struct.\n", "\n", "### **reduction** Clause\n", "\n", @@ -430,9 +430,10 @@ "|ior |omp_priv = 0 |omp_out = ior(omp_in, omp_out) |\n", "|ieor |omp_priv = 0 |omp_out = ieor(omp_in, omp_out) |\n", "\n", + "The **reduction** clause can be used multiple times as needed within a parallel struct.\n", "### **proc_bind** Clause\n", "\n", - "The **proc_bind** clause is used to specify a mapping of OpenMP threads to places within the current place partition for implicit tasks of the encountering threads. Its syntax is as follows:\n", + "The **proc_bind** clause is used to specify a mapping of OpenMP threads to places within the current place partition for implicit tasks of the encountering threads. At most one proc_bind clause can appear on the directive. Its syntax is as follows:\n", "```\n", "proc_bind(affinity-policy) \n", "```\n", @@ -451,6 +452,7 @@ "When the number of threads is equal to or less than **P**, the number of sub-partitions is equal to the number of threads **T**, and the threads are distributed in the first position of each partition in order of thread number from small to large. Conversely, when the number of threads is greater than **P**, **T/P** threads with consecutive thread numbers are allocated to each sub-partition. \n", "Sorted by thread number, the first **T/P** threads are allocated in the subpartition that contains the place of the parent thread. The remaining thread groups are allocated backward in turn, with a wrap-around with respect to the original place partition of the primary thread.\n", "\n", + "\n", "### **allocate** Clause\n", "The **allocate** clause is used to specify the memory allocator used to obtain storage of the private variables. When it is used with **parallel** construct, the syntax is shown as following:\n", "```\n", @@ -458,7 +460,9 @@ "```\n", "\n", "In C/C++, the *allocator* is an expression of the omp_allocator_handle_t type. In Fortran, the *allocator* is an integer expression of the omp_allocator_handle_kindkind. \n", - "We will not list these allocators here, readers can find them in the OpenMP specification, but we will explain some commonly used allocators in the examples in the following section." + "We will not list these allocators here, readers can find them in the OpenMP specification, but we will explain some commonly used allocators in the examples in the following section.\n", + "\n", + "The **allocate** clause can be used multiple times as needed within a parallel struct. " ] }, { From e5de8898da3d343b06fc1fa434324667cd4dcb02 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Mon, 26 Sep 2022 16:25:38 -0400 Subject: [PATCH 41/91] Added one example for if clause --- .../2_UsingOpenMP_parallel.ipynb | 113 ++++++++++++++++-- 1 file changed, 101 insertions(+), 12 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 11dd6c4..dd917e6 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -465,18 +465,92 @@ "The **allocate** clause can be used multiple times as needed within a parallel struct. " ] }, + { + "cell_type": "markdown", + "id": "c6acb505-4e89-4e93-9f5e-9034ead13466", + "metadata": {}, + "source": [ + "## More Advanced Examples of Using Other Clauses and the Analysis of Performance and Improvement" + ] + }, { "cell_type": "markdown", "id": "bbb0b499-66b1-4d59-a11f-e449b5cb9062", "metadata": {}, - "source": [] + "source": [ + "In the above section, we have introduced the syntax and semantics of all the clauses that can be used with the parallel directive. In this section, we introduce some examples of how to use these clauses.\n", + "\n", + "Meanwhile, in some of the examples, we will show some ways to improve performance, and discuss some potential possibilities for improving performance." + ] }, { "cell_type": "markdown", - "id": "c6acb505-4e89-4e93-9f5e-9034ead13466", + "id": "1dd8caab-b94f-4de5-8517-a718f6bfc074", "metadata": {}, "source": [ - "## More Advanced Examples of Using Other Clauses and the Analysis of Performance and Improvement" + "### **if** clause" + ] + }, + { + "cell_type": "markdown", + "id": "174ad19b-81ca-492c-8aac-9d570cb66b79", + "metadata": {}, + "source": [ + "The if clause can achieve conditional parallelism. In the following example, we use three cases to display the effect of the if clause. No if clause is used in case 1, we can get the output from four threads. The scalar expression in the if clause in case 2 is evaluated to be false, so the statements following the openMP directive (maybe code block in other cases) will be executed serially." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b4745ce8-dfcf-41ee-b370-78cba6770318", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World in case 1 from thread 0\n", + "Hello World in case 1 from thread 2\n", + "Hello World in case 1 from thread 3\n", + "Hello World in case 1 from thread 1\n", + "-------------------------------------------------\n", + "Hello World in case 2 from thread 0\n", + "-------------------------------------------------\n", + "Hello World in case 3 from thread 0\n", + "Hello World in case 3 from thread 1\n", + "Hello World in case 3 from thread 3\n", + "Hello World in case 3 from thread 2\n" + ] + } + ], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + " int M =10;\n", + " //case 1\n", + " #pragma omp parallel num_threads(4)\n", + " printf(\"Hello World in case 1 from thread %d\\n\", omp_get_thread_num());\n", + "\n", + " printf(\"-------------------------------------------------\\n\");\n", + " \n", + " //case 2\n", + " #pragma omp parallel num_threads(4) if(M > 10)\n", + " printf(\"Hello World in case 2 from thread %d\\n\", omp_get_thread_num());\n", + "\n", + " printf(\"-------------------------------------------------\\n\");\n", + " \n", + " //case 3\n", + " #pragma omp parallel num_threads(4) if(M <= 10)\n", + " printf(\"Hello World in case 3 from thread %d\\n\", omp_get_thread_num());\n", + " \n", + " return 0;\n", + "}" ] }, { @@ -486,16 +560,31 @@ "source": [ "## *if* clause\n", "\n", + "```\n", + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]){\n", + "int M =900;\n", + " #pragma omp parallel if(M > 800)\n", + "for(j=0;j< M; j++)\n", + "{\n", + "tid = omp_get_thread_num();\n", + " printf(\"Hello World from thread = %d\\n\", tid);\n", + "}\n", + " return 0;\n", + "}\n", + "```\n", + "#pragma omp parallel f if(M > 800)\n", + "for(j=0;j< M; j++)\n", + "{\n", + "aa[j] =alpha*bb[j] + cc[j];\n", + "}\n", "\n", - "//在CPU上，决定性能的因素有很多，回忆在上个章节中提到的能够改善性能的因素，\n", - "- Thread load balancing\n", - "- Minimizing synchronization.\n", - "- Using more efficient directives. For example, using PARALLEL DO/FOR instead of worksharing DO/FOR directives in parallel regions.\n", - "- Expansion or merging of parallel regions\n", - "- Improving cache hit rate\n", - "- Optimization of round-robin scheduling\n", - "- Variable property optimization\n", - "- Optimization to reduce false sharing problem\n", "\n", "\n", "\n" From e642ee3dd24f4381739c03bc5bf8ea031db10e17 Mon Sep 17 00:00:00 2001 From: michaelwomack2001 Date: Mon, 5 Dec 2022 11:59:59 -0500 Subject: [PATCH 42/91] synchronization --- .../4_SynchronizationThreads.ipynb | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb index 4a02560..3c2d369 100644 --- a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb @@ -7,11 +7,21 @@ "source": [ "# Synchronization of threads using barrier and order directive" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78a661e5-3bca-4157-bae6-45d81ffc704c", + "metadata": {}, + "outputs": [], + "source": [ + "OpenMP synchronization for parallel include barrier and .." + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -25,7 +35,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.8.10" } }, "nbformat": 4, From 6998de10e4c46a1f3a2731512315a9f3aba45023 Mon Sep 17 00:00:00 2001 From: michaelwomack2001 Date: Mon, 5 Dec 2022 13:06:23 -0500 Subject: [PATCH 43/91] synchronization --- src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb index 3c2d369..5f0f98f 100644 --- a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb @@ -9,13 +9,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "78a661e5-3bca-4157-bae6-45d81ffc704c", + "cell_type": "markdown", + "id": "47ec2fe5-66c0-40e3-aeb2-128ddef90823", "metadata": {}, - "outputs": [], "source": [ - "OpenMP synchronization for parallel include barrier and .." + "OpenMP synchronization for barrier and order directive. " ] } ], From a93d0da13cca9f1ddce3d860a5fcfb258d0e945b Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Mon, 5 Dec 2022 13:12:24 -0500 Subject: [PATCH 44/91] remove the .gitconfig file so username is not default --- .gitconfig | 3 --- .gitignore | 2 ++ 2 files changed, 2 insertions(+), 3 deletions(-) delete mode 100644 .gitconfig diff --git a/.gitconfig b/.gitconfig deleted file mode 100644 index 17c917d..0000000 --- a/.gitconfig +++ /dev/null @@ -1,3 +0,0 @@ -[user] - email = michaelwomack2001@gmail.com - name = michaelwomack2001 diff --git a/.gitignore b/.gitignore index 5e52795..a3a0e90 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,8 @@ __pycache__/ *.py[cod] *$py.class +.gitconfig + # C extensions *.so From f6685d127420c98d10b7968e52cada33339fb79a Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 6 Dec 2022 11:47:56 -0500 Subject: [PATCH 45/91] Update requirements.txt --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index f54423e..549fcdc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,5 +2,5 @@ jupyter-book matplotlib numpy pandas -sklearn +scikit-learn jupyter-native-kernel From 8e3bee917ace5684b05494f38e4333c08c7b3682 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 6 Dec 2022 11:51:31 -0500 Subject: [PATCH 46/91] Update publish.yml --- .github/workflows/publish.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index feefe10..a770b9b 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -17,11 +17,11 @@ jobs: deploy-book: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 # Install dependencies - name: Set up Python 3.8 - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: 3.8 From 9fcb90bf45682d11a76af545d23ff4c7770f7697 Mon Sep 17 00:00:00 2001 From: xinyao Date: Wed, 7 Dec 2022 15:05:21 -0500 Subject: [PATCH 47/91] Fixed some errors --- .../2_UsingOpenMP_parallel.ipynb | 74 ++++++------------- 1 file changed, 22 insertions(+), 52 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index dd917e6..11f4622 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -501,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 7, "id": "b4745ce8-dfcf-41ee-b370-78cba6770318", "metadata": {}, "outputs": [ @@ -509,16 +509,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Hello World in case 1 from thread 0\n", "Hello World in case 1 from thread 2\n", "Hello World in case 1 from thread 3\n", "Hello World in case 1 from thread 1\n", + "Hello World in case 1 from thread 0\n", "-------------------------------------------------\n", "Hello World in case 2 from thread 0\n", "-------------------------------------------------\n", - "Hello World in case 3 from thread 0\n", - "Hello World in case 3 from thread 1\n", "Hello World in case 3 from thread 3\n", + "Hello World in case 3 from thread 1\n", + "Hello World in case 3 from thread 0\n", "Hello World in case 3 from thread 2\n" ] } @@ -555,54 +555,24 @@ }, { "cell_type": "markdown", - "id": "159a781e-eeeb-44a6-bc33-4b5e95d0d9df", + "id": "35f744ac-de70-4c5d-a577-c04cee3fdff3", "metadata": {}, "source": [ - "## *if* clause\n", - "\n", - "```\n", - "//%compiler: clang\n", - "//%cflags: -fopenmp\n", - "\n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "int main(int argc, char *argv[]){\n", - "int M =900;\n", - " #pragma omp parallel if(M > 800)\n", - "for(j=0;j< M; j++)\n", - "{\n", - "tid = omp_get_thread_num();\n", - " printf(\"Hello World from thread = %d\\n\", tid);\n", - "}\n", - " return 0;\n", - "}\n", - "```\n", - "#pragma omp parallel f if(M > 800)\n", - "for(j=0;j< M; j++)\n", - "{\n", - "aa[j] =alpha*bb[j] + cc[j];\n", - "}\n", - "\n", - "\n", - "\n", - "\n" + "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the **omp_get_thread_num** library routine." ] }, { "cell_type": "markdown", - "id": "35f744ac-de70-4c5d-a577-c04cee3fdff3", + "id": "3d06ed2c-2001-465d-b761-7660ce42fb3b", "metadata": {}, "source": [ - "Within a parallel region, the thread number uniquely identifies each thread. A thread can obtain its own thread number by calling the **omp_get_thread_num** library routine.\n", - "\n", + "### Data-Sharing Attribute Clauses\n", "The following example is a little more complicated. It shows how to use the **omp_get_thread_num** library routine and shows how to use two other clauses, the **default** clause and the **private** clause. It assigns tasks to each thread explicitly." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "b1908c43", "metadata": {}, "outputs": [ @@ -681,9 +651,7 @@ "In the above example, variable *npoints* presents the total number of elements in the array, and it is divided into *nt* parts, each of size *ipoints*. The starting address of each part is *istart*. Each part is completed by one thread, and a total of 8 threads execute tasks in parallel.\n", "\n", "The **default** clause is used to define the default data-sharing attributes of variables that are referenced in a parallel, teams, or task-generating construct. In the above example, *default(shared)* indicates that by default, the variables in the parallel region are shared variables.\n", - "The **private** clause is used to explicitly specify variables that are private in each task or SIMD lane (SIMD will be introduced in the next chapter). In the above example, the variables *iam, nt, ipoints* and *istart* are private variables for each thread, which means a thread cannot access these variables of another thread.\n", - "\n", - "Both of these two clauses belong to the data-sharing attribute clauses, which we will introduce in detail in the section of clauses later." + "The **private** clause is used to explicitly specify variables that are private in each task or SIMD lane (SIMD will be introduced in the next chapter). In the above example, the variables *iam, nt, ipoints* and *istart* are private variables for each thread, which means a thread cannot access these variables of another thread." ] }, { @@ -696,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "9401fa8e-d1a7-46e1-8e6b-1077567d61ca", "metadata": {}, "outputs": [ @@ -704,7 +672,17 @@ "name": "stdout", "output_type": "stream", "text": [ - " \n" + " \n", + " 0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000 \n", + " 10.00000 11.00000 12.00000 13.00000 14.00000 15.00000 16.00000 17.00000 18.00000 19.00000 \n", + " 20.00000 21.00000 22.00000 23.00000 24.00000 25.00000 26.00000 27.00000 28.00000 29.00000 \n", + " 30.00000 31.00000 32.00000 33.00000 34.00000 35.00000 36.00000 37.00000 38.00000 39.00000 \n", + " 40.00000 41.00000 42.00000 43.00000 44.00000 45.00000 46.00000 47.00000 48.00000 49.00000 \n", + " 50.00000 51.00000 52.00000 53.00000 54.00000 55.00000 56.00000 57.00000 58.00000 59.00000 \n", + " 60.00000 61.00000 62.00000 63.00000 64.00000 65.00000 66.00000 67.00000 68.00000 69.00000 \n", + " 70.00000 71.00000 72.00000 73.00000 74.00000 75.00000 76.00000 77.00000 78.00000 79.00000 \n", + " 80.00000 81.00000 82.00000 83.00000 84.00000 85.00000 86.00000 87.00000 88.00000 89.00000 \n", + " 90.00000 91.00000 92.00000 93.00000 94.00000 95.00000 96.00000 97.00000 98.00000 99.00000" ] } ], @@ -763,14 +741,6 @@ " CALL PRINT(ARRAY, 100)\n", " END PROGRAM PAREXAMPLE" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "78bd8594-76fd-4fd6-b6db-e2b9a702229d", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 9d8eef693e2742f8cfefbfe0fa48dc7777337466 Mon Sep 17 00:00:00 2001 From: xinyao Date: Wed, 7 Dec 2022 15:16:30 -0500 Subject: [PATCH 48/91] Correct some description --- src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 11f4622..794ebca 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -488,7 +488,7 @@ "id": "1dd8caab-b94f-4de5-8517-a718f6bfc074", "metadata": {}, "source": [ - "### **if** clause" + "### **if** clause and **num_threads** clause" ] }, { @@ -496,7 +496,7 @@ "id": "174ad19b-81ca-492c-8aac-9d570cb66b79", "metadata": {}, "source": [ - "The if clause can achieve conditional parallelism. In the following example, we use three cases to display the effect of the if clause. No if clause is used in case 1, we can get the output from four threads. The scalar expression in the if clause in case 2 is evaluated to be false, so the statements following the openMP directive (maybe code block in other cases) will be executed serially." + "The **if** clause can achieve conditional parallelism and the **num_threads** clause will identify the number of threads used. In the following example, we use three cases to display the effect of the if clause and the **num_trheads** clause. No **if** clause is used in case 1, and the **num_threads** clause indicated we should use 4 threads, so we can get the output from four threads in parallel. The scalar expression in the **if** clause in case 2 is evaluated to be false, so the statements following the openMP directive (maybe code block in other cases) will be executed serially by only one thread. And in case 3, the scalar expression is evaluated to be true, so the statements following the openMP directive will be executed parallel by four threads." ] }, { From 6bb89a33b76835bfe4735eff4e9a4519299acd42 Mon Sep 17 00:00:00 2001 From: xinyao Date: Fri, 9 Dec 2022 09:32:02 -0500 Subject: [PATCH 49/91] Added a new example --- .../2_UsingOpenMP_parallel.ipynb | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 794ebca..c1e4e96 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -741,6 +741,49 @@ " CALL PRINT(ARRAY, 100)\n", " END PROGRAM PAREXAMPLE" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62f00f01-4760-4810-b1e2-af426c3de291", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "//This example is from https://www.openmp.org/wp-content/uploads/openmp-examples-5.1.pdf.\n", + "\n", + "#include \n", + "\n", + "int A[2][2] = {1, 2, 3, 4};\n", + "\n", + "void f(int n, int B[n][n], int C[]) {\n", + " int D[2][2] = {1, 2, 3, 4};\n", + " int E[n][n];\n", + "\n", + " assert(n >= 2);\n", + " E[1][1] = 4;\n", + "\n", + " #pragma omp parallel firstprivate(B, C, D, E)\n", + " {\n", + " assert(sizeof(B) == sizeof(int (*)[n]));\n", + " assert(sizeof(C) == sizeof(int*));\n", + " assert(sizeof(D) == 4 * sizeof(int));\n", + " assert(sizeof(E) == n * n * sizeof(int));\n", + "\n", + " /* Private B and C have values of original B and C. */\n", + " assert(&B[1][1] == &A[1][1]);\n", + " assert(&C[3] == &A[1][1]);\n", + " assert(D[1][1] == 4);\n", + " assert(E[1][1] == 4);\n", + " }\n", + "}\n", + "\n", + "int main() {\n", + " f(2, A, A[0]);\n", + " return 0;\n", + "}" + ] } ], "metadata": { From 5b1a9b50e5a8b68c646b8fa5584e3699bb787b9d Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 9 Dec 2022 12:32:06 -0500 Subject: [PATCH 50/91] Added some description for the new example. --- .../2_UsingOpenMP_parallel.ipynb | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index c1e4e96..18df471 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -784,6 +784,25 @@ " return 0;\n", "}" ] + }, + { + "cell_type": "markdown", + "id": "076f23d3-09f1-4ab4-a5b5-876a556ff849", + "metadata": {}, + "source": [ + "In the above example, we explored how to use the **firstprivate** clause. The size and values of the array or pointer appearing in the list of the **firstprivate** clause depend on the original arrays or pointers in the serial part.\n", + "The type of A is array of two arrays of two ints. B and C are function variables, which will be adjusted according to the type defined in the function. The type of B is pointer to array of n ints, and the type of C is pointer to int. The type of D is exactly the same as A, and the type of E is array of n arrays of n ints.\n", + "\n", + "In the example, we use multiple assert statements to check whether B, C, D, and E have the expected types and values. Thus to verify the function of the **firstprivate** clause." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ad52a5f-9257-46b7-99b8-2ba9fa8423b0", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 9077f5ad06c797d017e24853356011a45c319369 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 23 Jan 2024 18:07:01 -0500 Subject: [PATCH 51/91] Fixed the typos mentioned in the issues. --- src/openmp_c/1_IntroductionOfOpenMP.ipynb | 4 ++-- src/openmp_c/2_Syntax.ipynb | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/openmp_c/1_IntroductionOfOpenMP.ipynb b/src/openmp_c/1_IntroductionOfOpenMP.ipynb index 06b4ea6..47bf501 100644 --- a/src/openmp_c/1_IntroductionOfOpenMP.ipynb +++ b/src/openmp_c/1_IntroductionOfOpenMP.ipynb @@ -31,7 +31,7 @@ "![fork-join_model1](20190720101130709.png \"topic1\")\n", "![fork-join_model1](0_13209261094r4F.png \"topic2\")\n", "\n", - " Drwa a new figure, merge these 2 figures and shown the barrier in the new figure
    \n", + "\n", "All OpenMP programs start with a single thread which is the master thread. The master thread executes serially until it encounters the first parallel region. Parallel region is a block of code executed by all threads in a team simultaneously.\n", "\n", "When the master thread encounters a parallel region, i.e. when it encounters an OpenMP parallel instruction, it creates a thread group consisting of itself and some additional (possibly zero) worker threads. This process called fork.\n", @@ -71,7 +71,7 @@ "\n", "There are two differences between shared variables and private variables. The first is that shared variables are not allowed to share one name. Each variable is unique. Secondly, shared variables are stored in memory that all threads can access, and any thread can access shared variables at any time. The control of access conflicts is the responsibility of the user.\n", "\n", - "The other two features of this memory model are that data transfer is transparent to the programmer and synchronization takes olace, but it is mostly implicit." + "The other two features of this memory model are that data transfer is transparent to the programmer and synchronization takes place, but it is mostly implicit." ] }, { diff --git a/src/openmp_c/2_Syntax.ipynb b/src/openmp_c/2_Syntax.ipynb index 3cbd08f..f6fc8ac 100644 --- a/src/openmp_c/2_Syntax.ipynb +++ b/src/openmp_c/2_Syntax.ipynb @@ -10,7 +10,7 @@ "\n", "## How to compile OpenMP programs?\n", "\n", - "When compiling OpenMP programs, you need to use comiler flags to enable OpenMP, such as –openmp, -xopenmp, -fopenmp, -mp\n", + "When compiling OpenMP programs, you need to use compiler flags to enable OpenMP, such as –openmp, -xopenmp, -fopenmp, -mp\n", "\n", "In this book, all our examples are compiled using LLVM/Clang on Ubuntu 20.04. LLVM/Clang has the advantages of fast compilation speed, less memory usage, and modular design.\n", "To execute OpenMP code, you need to add -fopenmp when compiling. The full command to compile is \n", @@ -23,7 +23,7 @@ "\n", "## OpenMP Directives and Syntax\n", "A series of directives and clauses in OpenMP identify code blocks as parallel regions. Programmers only need to insert these directives into the code, so OpenMP is defined as a kind of directive_based language.\n", - "In C/C++, the directive is based on the #pragma omp construct. In Fortran, instructions begin with ! $omp. This is a regular language pragma (in C/C++) or a regular comment (in Fortran) for Compilers. So special option is need when the compiler is required to generate OpenMP code. Otherwise the compiler won't recognize it and simply ignore it.\n", + "In C/C++, the directive is based on the #pragma omp construct. In Fortran, instructions begin with ! $omp. This is a regular language pragma (in C/C++) or a regular comment (in Fortran) for compilers. So special option is need when the compiler is required to generate OpenMP code. Otherwise the compiler won't recognize it and simply ignore it.\n", "\n", "The basic format of OpenMP directive in C/C++ is as follows:\n", "```\n", @@ -79,7 +79,7 @@ "!$OMP PARALLEL\n", "10 wrk(id) = garbage(id)\n", " res(id) = wrk(id)**2\n", - " if(.not.conv(res(id)) goto 10\n", + " if(.not.conv(res(id))) goto 10\n", "!$OMP END PARALLEL\n", "```\n", "Another example:\n", From a9c9e43362f895ccf5711f1ce4d95b68a3131648 Mon Sep 17 00:00:00 2001 From: Sylvia Date: Mon, 8 Apr 2024 06:24:15 -0400 Subject: [PATCH 52/91] Added the content for 3_UsingOpenMP_teams.ipynb --- .../3_UsingOpenMP_teams.ipynb | 885 +++++++++++++++--- 1 file changed, 749 insertions(+), 136 deletions(-) diff --git a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb index 59d5b76..5af51e4 100644 --- a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb +++ b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -5,7 +5,7 @@ "id": "6d6f12df", "metadata": {}, "source": [ - "# Creating SPMD parallelism using OpenMP **teams** directive" + "# Creating SPMD parallelism using OpenMP `teams` directive" ] }, { @@ -13,7 +13,13 @@ "id": "e22c5131", "metadata": {}, "source": [ - "In this part, we will introduce how to use OpenMP **teams** directives to create SPMD parallelism." + "In OpenMP, the `teams` directive plays a crucial role, especially in the context of offloading computations to devices such as GPUs.\n", + "\n", + "The `teams` directive in OpenMP is used to create a league of thread teams, each of which can execute concurrently. This directive is particularly useful in scenarios where a hierarchical parallelism model is desired. For example, in GPU programming, a common pattern is to distribute work among multiple teams of threads, where each team can further parallelize the work among its member threads.\n", + "\n", + "Unlike the `parallel` directive, which is used to create a single team of threads, the `teams` directive allows for the creation of multiple teams, providing an additional level of parallelism. This makes the `teams` directive a powerful tool for exploiting the parallel capabilities of modern hardware architectures, especially in the context of heterogeneous computing.\n", + "\n", + "In this chapter, we will explore the basic usage of the `teams` directive, its interaction with other OpenMP directives, and how it can be used to target parallel execution on devices like GPUs. By the end of this chapter, you should have a solid understanding of the `teams` directive and how to leverage it to write efficient parallel programs with OpenMP." ] }, { @@ -21,208 +27,815 @@ "id": "18848ac3", "metadata": {}, "source": [ - "### **teams** Directive\n", - "The **teams** directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the **teams** directive to use a large number of thread teams.\n", + "## Basic Usage\n", + "\n", + "### `teams` Directive\n", + "The `teams` directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the `teams` directive to use a large number of thread teams.\n", "\n", - "The following figure shows the execution model of the **teams** directive:\n", + "The following figure shows the execution model of the `teams` directive:\n", "![teams_directive](teams.jpeg \"topic1\")\n", "\n", - "A league of teams is created when a thread encounters a **teams** construct. Each team is an initial team, and the initial thread in each team executes the team area.\n", - "After a team is created, the number of initial teams remains the same for the duration of the **teams** region.\n", - "Within a **teams** region, the initial team number uniquely identifies each initial team. A thread can obtain its own initial team number by calling the *omp_get_team_num* library routine.\n", + "A league of teams is created when a thread encounters a `teams` construct. Each team is an initial team, and the initial thread in each team executes the team area.\n", + "After a team is created, the number of initial teams remains the same for the duration of the `teams` region.\n", + "Within a `teams` region, the initial team number uniquely identifies each initial team. A thread can obtain its own initial team number by calling the *omp_get_team_num* library routine.\n", "The teams directive has the following characteristics:\n", - "- the **teams** directive can spawn one or more thread teams with the same number of threads\n", + "- the `teams` directive can spawn one or more thread teams with the same number of threads\n", "- code is portable for one thread team or multiple thread teams\n", "- only the primary thread of each team continues to execute\n", "- no synchronization between thread teams\n", "- programmers don't need to think about how to decompose loops\n", "\n", "OpenMP was originally designed for multithreading on shared-memory parallel computers, so the parallel directive only creates a single layer of parallelism.\n", - "The team instruction is used to express the second level of scalable parallelization. Before OpenMP 5.0, it can be only used on the GPU (with an associated target construct). In OpenMP 5.0 the **teams** construct was extended to enable the host to execute a teams region.\n" + "The team instruction is used to express the second level of scalable parallelization. Before OpenMP 5.0, it can be only used on the GPU (with an associated target construct). In OpenMP 5.0 the `teams` construct was extended to enable the host to execute a teams region.\n", + "\n", + "The syntax for the `teams` directive in C/C++ is:\n", + "\n", + "```c\n", + "#pragma omp teams [clause[ [,] clause] ... ] new-line\n", + " structured-block\n", + "```\n", + "\n", + "The syntax in Fortran is:\n", + "\n", + "```fortran\n", + "!$omp teams [clause[ [,] clause] ... ]\n", + " loosely-structured-block\n", + "!$omp end teams\n", + "```\n", + "\n", + "In its simplest form, the `teams` directive can be used without any clauses:\n", + "\n", + "```c\n", + "#pragma omp teams\n", + "{\n", + " // Code to be executed by each team\n", + "}\n", + "```\n", + "\n", + "This will create a league of teams, with the number of teams and the number of threads per team determined by the implementation. Typically, the number of teams is chosen to match the number of available processing units, such as cores or GPU compute units.\n", + "\n", + "### Example: Creating Teams\n", + "\n", + "Here's a basic example that demonstrates the use of the `teams` directive:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp teams\n", + " {\n", + " printf(\"Team %d out of %d teams\\n\", omp_get_team_num(), omp_get_num_teams());\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, each team will print its team number and the total number of teams. The `omp_get_team_num()` function returns the team number of the calling thread, and the `omp_get_num_teams()` function returns the total number of teams in the current league.\n", + "\n", + "When executed, the program might produce output similar to the following, depending on the number of teams created by the implementation:\n", + "\n", + "```\n", + "Team 0 out of 4 teams\n", + "Team 1 out of 4 teams\n", + "Team 2 out of 4 teams\n", + "Team 3 out of 4 teams\n", + "```\n", + "\n", + "This simple example demonstrates the basic usage of the `teams` directive to create multiple teams of threads. In the following sections, we will explore how to control the number of teams and threads, and how the `teams` directive interacts with other OpenMP directives for more complex parallel programming scenarios.\n" ] }, { - "cell_type": "code", - "execution_count": 2, - "id": "897482af", + "cell_type": "markdown", + "id": "463500c6-2694-4874-af2f-70fcc0ac9987", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "clang: fatal error: cannot find libdevice for sm_35. Provide path to different CUDA installation via --cuda-path, or pass -nocudalib to build without linking with libdevice.\n", - "[Native kernel] clang exited with code 1, the executable will not be executed" - ] - } - ], "source": [ - "//%compiler: clang\n", - "//%cflags: -fopenmp -fopenmp-targets=nvptx64-nvidia-cuda -std=c++11 -Wall -Wno-unused-result -Wno-unknown-pragmas -Wfatal-errors -fPIC -fopenmp -fopenmp-targets=nvptx64\n", - "#include \n", - "#include \n", - "float dotprod(float B[], float C[], int N) {\n", - " float sum0 = 0.0;\n", - " float sum1 = 0.0;\n", - " #pragma omp target map(to: B[:N], C[:N]) map(tofrom: sum0, sum1)\n", - " #pragma omp teams num_teams(2) \n", - " {\n", - " int i;\n", - " if (omp_get_num_teams() != 2)\n", - " abort();\n", - " if (omp_get_team_num() == 0) {\n", - " #pragma omp parallel for reduction(+:sum0)\n", - " for (i=0; i\n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 1000;\n", + " int array[N];\n", + " int sum = 0;\n", + "\n", + " // Initialize the array with some values\n", + " for (int i = 0; i < N; i++) {\n", + " array[i] = i;\n", + " }\n", + "\n", + " #pragma omp target teams distribute reduction(+:sum)\n", + " for (int i = 0; i < N; i++) {\n", + " sum += array[i];\n", + " }\n", + "\n", + " printf(\"Sum: %d\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the loop iterations are distributed across teams, and each team contributes to the reduction operation to calculate the sum of the array elements.\n", + "\n", + "### Teams and Parallel Directives\n", + "\n", + "The `teams` directive can also be combined with the `parallel` directive to create nested parallelism. Within each team, the `parallel` directive creates a parallel region where multiple threads can work concurrently.\n", + "\n", + "**Example:** Using nested parallelism with the `teams` and `parallel` directives to perform matrix multiplication.\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "#define M 1000\n", + "#define P 1000\n", + "\n", + "int main() {\n", + " double A[N][M], B[M][P], C[N][P];\n", + "\n", + " // Initialize matrices A and B\n", + " // ...\n", + "\n", + " #pragma omp target teams\n", + " {\n", + " #pragma omp distribute parallel for collapse(2)\n", + " for (int i = 0; i < N; i++) {\n", + " for (int j = 0; j < P; j++) {\n", + " double sum = 0.0;\n", + " for (int k = 0; k < M; k++) {\n", + " sum += A[i][k] * B[k][j];\n", + " }\n", + " C[i][j] = sum;\n", + " }\n", " }\n", " }\n", - " return sum0 + sum1;\n", + "\n", + " // Print matrix C\n", + " // ...\n", + "\n", + " return 0;\n", "}\n", - "/* Note: The variables sum0,sum1 are now mapped with tofrom, for correct\n", - " execution with 4.5 (and pre-4.5) compliant compilers. See Devices Intro.\n", - " */" + "```\n", + "\n", + "In this example, the outer loop iterations (over `i` and `j`) are distributed across teams, and within each team, the loop iterations are executed in parallel by the team's threads.\n", + "\n", + "### Teams and Target Directives\n", + "\n", + "The `teams` directive is commonly used with the `target` directive for offloading computations to a device, such as a GPU. The `target` directive specifies that the code block should be executed on the device, and the `teams` directive creates teams of threads on the device to execute the code.\n", + "\n", + "**Example:** Offloading a computation to a device and using teams to perform the computation in parallel.\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "int main() {\n", + " float A[N], B[N], C[N];\n", + "\n", + " // Initialize arrays A and B\n", + " // ...\n", + "\n", + " #pragma omp target teams map(to: A, B) map(from: C)\n", + " {\n", + " #pragma omp distribute parallel for\n", + " for (int i = 0; i < N; i++) {\n", + " C[i] = A[i] + B[i];\n", + " }\n", + " }\n", + "\n", + " // Print array C\n", + " // ...\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the computation of the element-wise sum of two arrays is offloaded to a device. The `teams` directive is used to create teams of threads on the device, and the `distribute parallel for` construct is used to distribute the loop iterations across the teams and execute them in parallel.\n", + "\n", + "### Summary\n", + "\n", + "The `teams` directive provides a flexible way to create a hierarchical parallelism model in OpenMP. By combining the `teams` directive with the `distribute`, `parallel`, and `target` directives, developers can efficiently utilize the parallel capabilities of both CPUs and GPUs for a wide range of applications." ] }, { - "cell_type": "code", - "execution_count": 1, - "id": "315a724a", + "cell_type": "markdown", + "id": "ee8d1f71-032d-484f-a98c-b9fc8745b98a", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Warning #96: Cannot form a team with 12 threads, using 6 instead.\n", - "OMP: Hint Consider unsetting KMP_DEVICE_THREAD_LIMIT (KMP_ALL_THREADS), KMP_TEAMS_THREAD_LIMIT, and OMP_THREAD_LIMIT (if any are set).\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "i=999 sp|dp 999.000000 999.000010 \n", - "i=500 sp|dp 500.000000 500.000005 \n" - ] - } - ], "source": [ - "//%compiler: clang\n", - "//%cflags: -fopenmp\n", + "## Data Environment\n", "\n", - "// Need to update the native kernel, or specified that our kernel doesn't support OpenMP 5.0\n", + "The `teams` directive in OpenMP creates a new data environment for the region of code it encloses. This section discusses the data-sharing attributes and other aspects of the data environment created by the `teams` directive.\n", "\n", + "### Data-Sharing Attributes\n", "\n", - "#include \n", - "#include \n", - "#include \n", + "Within a `teams` region, variables can have one of the following data-sharing attributes: shared, private, firstprivate, or reduction. The default data-sharing attribute for variables in a `teams` region is determined by the default clause if present; otherwise, it follows the rules of the OpenMP specification.\n", + "\n", + "- **Shared:** Variables with the shared attribute are shared among all threads in all teams. Each team accesses the same storage location for shared variables.\n", + "- **Private:** Variables with the private attribute have a separate copy for each thread. Each thread in each team has its own copy of private variables.\n", + "- **Firstprivate:** Similar to private, but each thread's copy is initialized with the value of the variable before entering the `teams` region.\n", + "- **Reduction:** Variables with the reduction attribute are subject to a reduction operation at the end of the `teams` region.\n", + "\n", + "### Example: Data-Sharing Attributes in Teams Region\n", + "\n", + "```c\n", "#include \n", - "#define N 1000\n", - " \n", - "int main(){\n", - " int nteams_required=2, max_thrds, tm_id;\n", - " float sp_x[N], sp_y[N], sp_a=0.0001e0;\n", - " double dp_x[N], dp_y[N], dp_a=0.0001e0;\n", - "\n", - " // Create 2 teams, each team works in a different precision\n", - " #pragma omp teams num_teams(nteams_required) thread_limit(max_thrds) private(tm_id)\n", - " {\n", - " tm_id = omp_get_team_num();\n", - " if( omp_get_num_teams() != 2 ) //if only getting 1, quit \n", - " { \n", - " printf(\"error: Insufficient teams on host, 2 required\\n\");\n", - " exit(0);\n", + "#include \n", + "\n", + "int main() {\n", + " int shared_var = 100;\n", + " int private_var = 200;\n", + "\n", + " #pragma omp target teams map(shared_var) private(private_var)\n", + " {\n", + " // Inside the teams region\n", + " private_var += omp_get_team_num();\n", + " #pragma omp parallel reduction(+:shared_var)\n", + " {\n", + " shared_var += private_var;\n", " }\n", - " if(tm_id == 0) // Do Single Precision Work (SAXPY) with this team\n", + " }\n", + "\n", + " printf(\"Shared variable: %d\\n\", shared_var);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, `shared_var` is shared among all teams and threads, while `private_var` is private to each thread. The value of `shared_var` is modified through a reduction operation within the parallel region inside the teams region.\n", + "\n", + "### Summary\n", + "\n", + "Understanding the data environment and data-sharing attributes in a `teams` region is crucial for writing correct and efficient parallel programs with OpenMP. Properly managing the data environment ensures that data is correctly shared or privatized among teams and threads, avoiding data races and other concurrency issues." + ] + }, + { + "cell_type": "markdown", + "id": "1f51b6ff-cb99-4636-bbc9-e47852385675", + "metadata": {}, + "source": [ + "## Clauses\n", + "\n", + "The `teams` directive in OpenMP can be used with several clauses to control the behavior of the teams and the data environment. This section discusses the clauses with the `teams` directive.\n", + "\n", + "### num_teams Clause\n", + "\n", + "**Syntax:** `num_teams(integer-expression)`\n", + "\n", + "The `num_teams` clause specifies the number of teams to be created in the teams region.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams num_teams(4)\n", + " {\n", + " printf(\"Team %d out of %d teams\\n\", omp_get_team_num(), omp_get_num_teams());\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### thread_limit Clause\n", + "\n", + "**Syntax:** `thread_limit(integer-expression)`\n", + "\n", + "The `thread_limit` clause specifies the maximum number of threads that can be part of each team.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams thread_limit(8)\n", + " {\n", + " #pragma omp parallel\n", " {\n", - " #pragma omp parallel\n", - " {\n", - " #pragma omp for //init\n", - " for(int i=0; i\n", + "#include \n", + "\n", + "int main() {\n", + " int sum = 0;\n", + "\n", + " #pragma omp target teams map(tofrom: sum) reduction(+:sum)\n", + " {\n", + " #pragma omp parallel\n", " {\n", - " #pragma omp parallel\n", - " {\n", - " #pragma omp for //init\n", - " for(int i=0; i\n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams default(none)\n", + " {\n", + " int x;\n", + " // Code that uses the variable x\n", + " }\n", " return 0;\n", - "} " + "}\n", + "```\n", + "\n", + "### allocate Clause\n", + "\n", + "**Syntax:** `allocate([allocator:] list)`\n", + "\n", + "The `allocate` clause specifies the allocator to be used for the variables in the list.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams allocate(x)\n", + " {\n", + " // Code that uses the variable x\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### shared Clause\n", + "\n", + "**Syntax:** `shared(list)`\n", + "\n", + "The `shared` clause specifies that the data within a parallel region is shared among all threads.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams shared(x)\n", + " {\n", + " // All threads in the team share the variable x\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### private Clause\n", + "\n", + "**Syntax:** `private(list)`\n", + "\n", + "The `private` clause specifies that each thread should have its own instance of a variable.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams private(x)\n", + " {\n", + " // Each thread has its own private copy of x\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### firstprivate Clause\n", + "\n", + "**Syntax:** `firstprivate(list)`\n", + "\n", + "The `firstprivate` clause provides each thread with its own copy of a variable and initializes each copy with the value of the variable at the time the parallel region is entered.\n", + "\n", + "**Example:**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams firstprivate(x)\n", + " {\n", + " // Each thread has its own copy of x, initialized with the value of x\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### Summary\n", + "\n", + "Clauses provide a powerful way to customize the behavior of the `teams` directive in OpenMP. By using clauses like `num_teams`, `thread_limit`, `reduction`, `default`, `allocate`, `shared`, `private`, and `firstprivate`, programmers can control various aspects of the teams' behavior and the data environment." ] }, { "cell_type": "markdown", - "id": "b615bdfb", + "id": "1d39d0c9-4948-4868-87a0-f94bd39138a9", "metadata": {}, "source": [ - "Its syntax is:\n", - "```\n", - "#pragma omp teams [clause[ [,] clause] ... ] new-line\n", - " structured-block\n", - "```\n", - "The syntax in Fortran is:\n", + "## Targeting Devices\n", + "\n", + "In modern computing, harnessing the power of specialized hardware such as Graphics Processing Units (GPUs) is essential for achieving high performance in parallel computing. OpenMP provides a seamless way to offload computations to these devices using the `target` and `teams` directives.\n", + "\n", + "### Offloading with Target and Teams Directives\n", + "\n", + "The `target` directive instructs the compiler to execute the enclosed code block on a specified device, typically a GPU. The `teams` directive, when used in conjunction with `target`, creates a league of thread teams to execute the code in parallel on the device.\n", + "\n", + "**Example: Vector Addition on a GPU**\n", + "\n", + "Consider the following example where two arrays are added element-wise and the result is stored in a third array:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 1000;\n", + " float a[N], b[N], c[N];\n", + "\n", + " // Initialize the input arrays\n", + " for (int i = 0; i < N; i++) {\n", + " a[i] = i * 1.0f;\n", + " b[i] = i * 2.0f;\n", + " }\n", + "\n", + " // Offload the computation to a GPU\n", + " #pragma omp target teams map(to: a, b) map(from: c)\n", + " {\n", + " #pragma omp distribute parallel for\n", + " for (int i = 0; i < N; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + " }\n", + "\n", + " // Output the result\n", + " for (int i = 0; i < N; i++) {\n", + " printf(\"%f \", c[i]);\n", + " }\n", + "\n", + " return 0;\n", + "}\n", "```\n", - "!$omp teams [clause[ [,] clause] ... ]\n", - " loosely-structured-block\n", - "!$omp end teams\n", - "```" + "\n", + "In this example, the `target teams` directive offloads the addition of arrays `a` and `b` to a GPU. The `map` clauses specify how data is transferred between the host and the device. The `distribute parallel for` directive ensures that the computation is performed in parallel by the teams of threads on the device.\n", + "\n", + "### Leveraging Device Parallelism\n", + "\n", + "Using the `teams` directive with the `target` directive enables you to harness the parallel processing capabilities of devices like GPUs. It allows for scalable parallel execution where the workload is distributed across multiple teams of threads, each executing concurrently on the device.\n", + "\n", + "### Summary\n", + "\n", + "The integration of the `teams` directive with the `target` directive in OpenMP provides a powerful and flexible approach to offloading computations to devices. This capability allows programmers to efficiently utilize the parallel processing power of GPUs and other devices, thereby enhancing the performance of parallel applications. In the following chapters, we will delve deeper into the `map` clause and explore other aspects of device offloading in OpenMP." ] }, { "cell_type": "markdown", - "id": "d0629b36", + "id": "16395d7a-5314-4c55-9c6d-0405abf0c703", "metadata": {}, "source": [ - "## Clauses" + "## Best Practices for Effective Use of Teams Directive\n", + "\n", + "Optimizing the use of the `teams` directive in OpenMP is crucial for harnessing the full potential of parallel computing, especially when offloading computations to devices such as GPUs. Here are some essential best practices to keep in mind:\n", + "\n", + "### Optimal Team Configuration\n", + "\n", + "Selecting the appropriate number of teams is pivotal. It should be aligned with the target device's architecture and the computational workload. For GPUs, a rule of thumb is to create a number of teams that corresponds to a multiple of the device's compute units.\n", + "\n", + "### Workload Distribution\n", + "\n", + "Achieving a balanced distribution of work among teams is key to avoiding performance bottlenecks. Utilize the `distribute` directive in tandem with `teams` to ensure an equitable assignment of loop iterations or other computational tasks across the teams.\n", + "\n", + "**Example: Workload Distribution**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 10000\n", + "\n", + "int main() {\n", + " float array[N];\n", + "\n", + " // Initialize the array\n", + " for (int i = 0; i < N; i++) {\n", + " array[i] = i;\n", + " }\n", + "\n", + " // Distribute workload evenly among teams\n", + " #pragma omp target teams map(tofrom: array)\n", + " #pragma omp distribute\n", + " for (int i = 0; i < N; i++) {\n", + " array[i] = array[i] * 2.0f;\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### Minimizing Data Movement\n", + "\n", + "Data transfer between the host and the device can significantly impact performance. Employ the `map` clause with precision to reduce unnecessary data movement. Additionally, explore techniques like data prefetching and overlapping data transfers with computation to enhance data locality.\n", + "\n", + "**Example: Efficient Data Movement**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 10000\n", + "\n", + "int main() {\n", + " float input[N], output[N];\n", + "\n", + " // Initialize the input array\n", + " for (int i = 0; i < N; i++) {\n", + " input[i] = i;\n", + " }\n", + "\n", + " // Minimize data movement in offloading\n", + " #pragma omp target teams map(to: input) map(from: output)\n", + " {\n", + " #pragma omp distribute parallel for\n", + " for (int i = 0; i < N; i++) {\n", + " output[i] = input[i] * 2.0f;\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### Efficient Reductions\n", + "\n", + "Ensure that reductions are performed efficiently, especially when using the `reduction` clause with the `teams` directive. Implement parallel reduction algorithms that leverage the device's parallel processing capabilities to avoid bottlenecks.\n", + "\n", + "**Example: Parallel Reduction**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 10000\n", + "\n", + "int main() {\n", + " float array[N];\n", + " float sum = 0.0f;\n", + "\n", + " // Initialize the array\n", + " for (int i = 0; i < N; i++) {\n", + " array[i] = i;\n", + " }\n", + "\n", + " // Efficient reduction on the device\n", + " #pragma omp target teams map(to: array) reduction(+:sum)\n", + " {\n", + " #pragma omp distribute parallel for\n", + " for (int i = 0; i < N; i++) {\n", + " sum += array[i];\n", + " }\n", + " }\n", + "\n", + " printf(\"Sum: %f\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "### Debugging and Profiling\n", + "\n", + "Leverage OpenMP-aware debugging and profiling tools to identify and address performance bottlenecks. Regularly verify the correctness of parallel execution to ensure the expected behavior of your application.\n", + "\n", + "### Conclusion\n", + "\n", + "Adhering to these best practices will enable you to maximize the efficiency and correctness of your parallel applications using the `teams` directive in OpenMP. Tailor your approach to the specific requirements of your application and the capabilities of your target device for optimal results." ] }, { "cell_type": "markdown", - "id": "1fc04bb4", + "id": "9fb90664-069e-4702-b56a-fdf287072021", "metadata": {}, - "source": [] + "source": [ + "## Advanced Topics\n", + "\n", + "While the basic usage of the `teams` directive provides a powerful tool for parallel computing, there are several advanced topics that can further enhance the performance and flexibility of your OpenMP applications. Here are some advanced topics related to the `teams` directive:\n", + "\n", + "### Nested Parallelism\n", + "\n", + "OpenMP supports nested parallelism, where a parallel region can be defined inside another parallel region. This can be particularly useful when using the `teams` directive to create a hierarchical parallelism model.\n", + "\n", + "**Example: Nested Parallelism**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp target teams\n", + " {\n", + " // Outer parallel region executed by teams\n", + " #pragma omp parallel\n", + " {\n", + " // Inner parallel region executed by threads within each team\n", + " printf(\"Team %d, Thread %d\\n\", omp_get_team_num(), omp_get_thread_num());\n", + " }\n", + " }\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, an outer parallel region is created by the `teams` directive, and an inner parallel region is created by the `parallel` directive. Each team of threads executes the inner parallel region independently.\n", + "\n", + "### SIMD Parallelism\n", + "\n", + "The `teams` directive can be combined with SIMD (Single Instruction, Multiple Data) constructs to exploit vector parallelism on devices that support SIMD instructions.\n", + "\n", + "**Example: SIMD Parallelism**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 10000\n", + "\n", + "int main() {\n", + " float array[N];\n", + "\n", + " // Initialize the array\n", + " for (int i = 0; i < N; i++) {\n", + " array[i] = i;\n", + " }\n", + "\n", + " // Use SIMD parallelism within teams\n", + " #pragma omp target teams map(tofrom: array)\n", + " #pragma omp distribute\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp simd\n", + " for (int j = 0; j < N; j++) {\n", + " array[j] = array[j] + 1.0f;\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `simd` directive is used within the loop to enable SIMD parallelism, allowing multiple elements of the array to be processed simultaneously by SIMD instructions.\n", + "\n", + "### Interoperability with Other Programming Models\n", + "\n", + "OpenMP can interoperate with other programming models, such as MPI (Message Passing Interface) or CUDA, to take advantage of specific features of different parallel programming approaches.\n", + "\n", + "**Example: Interoperability with MPI**\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main(int argc, char *argv[]) {\n", + " MPI_Init(&argc, &argv);\n", + "\n", + " int rank;\n", + " MPI_Comm_rank(MPI_COMM_WORLD, &rank);\n", + "\n", + " #pragma omp target teams\n", + " {\n", + " printf(\"MPI Rank %d, Team %d\\n\", rank, omp_get_team_num());\n", + " }\n", + "\n", + " MPI_Finalize();\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, OpenMP is used in conjunction with MPI, where each MPI process executes an OpenMP `teams` region on a device. This allows for a hybrid parallel programming approach that combines distributed memory parallelism (MPI) with shared memory parallelism (OpenMP).\n", + "\n", + "### Summary\n", + "\n", + "Exploring advanced topics related to the `teams` directive can unlock new levels of performance and flexibility in your OpenMP applications. Whether it's leveraging nested parallelism, exploiting SIMD instructions, or interoperating with other programming models, these advanced techniques can help you tackle complex parallel computing challenges." + ] }, { "cell_type": "markdown", - "id": "e16a6d8d", + "id": "42cc6c54-4640-453e-8956-bfdc4d80ee18", "metadata": {}, - "source": [] + "source": [ + "## Summary\n", + "\n", + "The `teams` directive is a powerful feature in OpenMP that enables the creation of a league of thread teams for parallel execution, particularly on devices such as GPUs. This chapter has covered the fundamental concepts, usage, and best practices associated with the `teams` directive, along with advanced topics for further exploration.\n", + "\n", + "Key takeaways from this chapter include:\n", + "\n", + "- **Basic Usage:** The `teams` directive, often used in conjunction with the `target` directive, allows for offloading computations to a device with a specified number of teams and threads.\n", + "- **Data Environment:** Understanding and managing the data environment, including data-sharing attributes and clauses like `allocate`, `default`, `shared`, and `private`, is crucial for efficient parallel execution.\n", + "- **Targeting Devices:** The combination of `target` and `teams` directives provides a flexible and powerful approach to offload computations to devices, with the `map` clause playing a vital role in managing data movement.\n", + "- **Best Practices:** To maximize performance and ensure correct execution, it's important to choose the right number of teams, balance the workload among teams, minimize data movement, use reductions efficiently, and employ debugging and profiling tools.\n", + "- **Advanced Topics:** Exploring nested parallelism, SIMD parallelism, and interoperability with other programming models can further enhance the capabilities of your OpenMP applications.\n", + "\n", + "By mastering the use of the `teams` directive, you can unlock new levels of parallelism and performance in your applications, making them more scalable and efficient on modern computing architectures." + ] }, { "cell_type": "markdown", - "id": "a252f343", + "id": "b6f6c8da-534b-4213-9d04-ce3825a2ec93", "metadata": {}, "source": [ - "## Examples" + "## Exercises\n", + "\n", + "1. **Nested Parallelism:** Modify the example code for nested parallelism to create a hierarchy of parallel regions using the `teams` directive. Experiment with different numbers of teams and threads to observe the performance impact.\n", + "\n", + "2. **SIMD Parallelism:** Implement a matrix multiplication algorithm using SIMD parallelism within the `teams` directive. Compare the performance of the SIMD-parallelized version with a non-parallelized version.\n", + "\n", + "3. **Load Balancing:** Write a program that performs a computation on a large array and uses the `distribute` directive to distribute the workload among teams. Experiment with different load balancing strategies to minimize load imbalance.\n", + "\n", + "4. **Reduction Operation:** Modify the example code for the reduction clause to perform a more complex reduction operation, such as finding the maximum or minimum value in an array, using the `teams` directive.\n", + "\n", + "5. **Interoperability:** Explore interoperability between OpenMP and another parallel programming model, such as MPI or CUDA. Write a program that combines both programming models to perform a parallel computation.\n", + "\n", + "6. **Debugging and Profiling:** Use an OpenMP-aware debugging or profiling tool to analyze the performance of one of the previous exercises. Identify any performance bottlenecks and propose optimizations.\n", + "\n", + "7. **Optimization Strategies:** Experiment with different optimization strategies, such as loop unrolling, loop tiling, or data prefetching, within the `teams` directive to improve the performance of a parallelized computation.\n", + "\n", + "8. **Real-world Application:** Identify a real-world application that can benefit from parallelization using the `teams` directive. Write a program that parallelizes a relevant part of the application and measure the performance improvement.\n", + "\n", + "9. **Scalability Analysis:** Conduct a scalability analysis of one of the previous exercises by varying the problem size and the number of teams/threads. Determine the scalability limits of your parallelized code.\n", + "\n", + "10. **Advanced Topics Exploration:** Choose one of the advanced topics discussed in this chapter, such as nested parallelism or SIMD parallelism, and explore it further by implementing a more complex example or conducting a detailed performance analysis." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "458eafdb-0359-438b-ad9d-c8055cfa52e6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" } }, "nbformat": 4, From 53b0fcbda575e1b58bfcbfe39e49ea1ab1821c8a Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Mon, 8 Apr 2024 10:48:08 -0400 Subject: [PATCH 53/91] Update _config.yml Update the author list --- src/_config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/_config.yml b/src/_config.yml index c8a7379..a9a40ff 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -2,7 +2,7 @@ # Learn more at https://jupyterbook.org/customize/config.html title: Parallel Programming and Performance Optimization With OpenMP -author: Michael Womack, Anjia Wang, Patrick Flynn, Xinyao Yi, Yonghong Yan +author: Xinyao Yi, Anjia Wang, and Yonghong Yan logo: logo.png # Force re-execution of notebooks on each build. From 593130deeb8e4aa649b6f63d2485c19a4dcd5ac8 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 9 Apr 2024 02:00:54 -0700 Subject: [PATCH 54/91] Update _config.yml --- src/_config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/_config.yml b/src/_config.yml index a9a40ff..aae182d 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -12,6 +12,7 @@ execute: launch_buttons: notebook_interface: "jupyterlab" + binderhub_url: "https://mybinder.org" # Define the name of the latex output file for PDF builds latex: From 283555de8969bb5dd588a0bd4bd8439faf6ca2c4 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 9 Apr 2024 02:03:47 -0700 Subject: [PATCH 55/91] Update publish.yml --- .github/workflows/publish.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index a770b9b..3de7371 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -12,18 +12,18 @@ on: # paths: # - some-subfolder/** -# This job installs dependencies, build the book, and pushes it to `gh-pages` +# This job installs dependencies, builds the book, and pushes it to `gh-pages`. jobs: deploy-book: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 # Install dependencies - - name: Set up Python 3.8 - uses: actions/setup-python@v4 + - name: Set up Python 3.11 + uses: actions/setup-python@v5 with: - python-version: 3.8 + python-version: 3.11 - name: Install dependencies run: | @@ -36,7 +36,7 @@ jobs: # Push the book's HTML to github-pages - name: GitHub Pages action - uses: peaceiris/actions-gh-pages@v3 + uses: peaceiris/actions-gh-pages@v4 with: github_token: ${{ secrets.GITHUB_TOKEN }} publish_dir: ./src/_build/html From 3092fb053b9bf6227d6918818cfd8490f94ff4b0 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 9 Apr 2024 02:04:41 -0700 Subject: [PATCH 56/91] Update Dockerfile --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index db02b2b..a44b217 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM ubuntu:20.04 +FROM ubuntu:22.04 ENV TZ=US/Eastern RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone From 5c68a65bed595cd48627a644ff6513a213746134 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Tue, 9 Apr 2024 18:54:43 -0700 Subject: [PATCH 57/91] Add files via upload --- src/logo.png | Bin 0 -> 3300 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/logo.png diff --git a/src/logo.png b/src/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..7fe18ce49ab1e63c839ef3fa503d4d35ea58015b GIT binary patch literal 3300 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 iPyti`6+ne$WB&o{o8C{n)T1u|0000 Date: Tue, 9 Apr 2024 18:55:10 -0700 Subject: [PATCH 58/91] Update publish.yml --- .github/workflows/publish.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 3de7371..a386ed9 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -32,7 +32,7 @@ jobs: # Build the book - name: Build the book run: | - jupyter-book build src + jupyter-book build src -W # Push the book's HTML to github-pages - name: GitHub Pages action From 1b71b6df8b40ef046d02c4c6c9da7d3328aceeba Mon Sep 17 00:00:00 2001 From: Sylvia Date: Sun, 21 Apr 2024 18:31:43 -0400 Subject: [PATCH 59/91] Fixed some warnings. --- src/Ch2_MulticoreMultiCPU.md | 1 + src/GPUAccelerators/plan.md | 4 - .../1_MIMDArchitecture.ipynb | 2 +- .../2_UsingOpenMP_parallel.ipynb | 19 +- .../3_UsingOpenMP_teams.ipynb | 1 + .../4_SynchronizationThreads.ipynb | 2 +- src/MultiCoreMultiCPU/plan.md | 38 - src/SomethingMayUsefulInFuture/build_rex.md | 126 - .../decision_tree/agaricuslepiotatest1.csv | 2126 ------ .../decision_tree/agaricuslepiotatrain1.csv | 6001 ----------------- .../decision_tree/decision_tree.ipynb | 696 -- src/SomethingMayUsefulInFuture/logo.png | Bin 9854 -> 0 bytes src/SomethingMayUsefulInFuture/markdown.md | 125 - .../notebooks.ipynb | 122 - src/SomethingMayUsefulInFuture/preface.md | 2 - src/_toc.yml | 17 +- src/book_intro.md | 1 + src/openmp_c/1_IntroductionOfOpenMP.ipynb | 19 +- src/openmp_c/2_Syntax.ipynb | 19 +- src/openmp_c/3_performance.ipynb | 2 +- src/openmp_c/parallel_for.ipynb | 301 - 21 files changed, 55 insertions(+), 9569 deletions(-) delete mode 100644 src/GPUAccelerators/plan.md delete mode 100644 src/MultiCoreMultiCPU/plan.md delete mode 100644 src/SomethingMayUsefulInFuture/build_rex.md delete mode 100644 src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv delete mode 100644 src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv delete mode 100644 src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb delete mode 100644 src/SomethingMayUsefulInFuture/logo.png delete mode 100644 src/SomethingMayUsefulInFuture/markdown.md delete mode 100644 src/SomethingMayUsefulInFuture/notebooks.ipynb delete mode 100644 src/SomethingMayUsefulInFuture/preface.md delete mode 100644 src/openmp_c/parallel_for.ipynb diff --git a/src/Ch2_MulticoreMultiCPU.md b/src/Ch2_MulticoreMultiCPU.md index feac574..c981a47 100644 --- a/src/Ch2_MulticoreMultiCPU.md +++ b/src/Ch2_MulticoreMultiCPU.md @@ -3,3 +3,4 @@ Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. In this book, we will be discussing multicore and multi CPU machines and how they work, how to use them, and how to optimize your code to use them effectively. + diff --git a/src/GPUAccelerators/plan.md b/src/GPUAccelerators/plan.md deleted file mode 100644 index 7de0089..0000000 --- a/src/GPUAccelerators/plan.md +++ /dev/null @@ -1,4 +0,0 @@ -Parallel Programming for GPU Accelerators -========================================= - -Temporary page indicating start of a section \ No newline at end of file diff --git a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb index 5ccd5ab..a0e35c8 100644 --- a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb +++ b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -144,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 18df471..735e83b 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -807,14 +807,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" }, "toc-showcode": false }, diff --git a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb index 5af51e4..a1f3cf7 100644 --- a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb +++ b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -33,6 +33,7 @@ "The `teams` directive indicates that the loop that follows is split among multiple thread teams, one thread team computing one part of the task. Developers can use the `teams` directive to use a large number of thread teams.\n", "\n", "The following figure shows the execution model of the `teams` directive:\n", + "\n", "![teams_directive](teams.jpeg \"topic1\")\n", "\n", "A league of teams is created when a thread encounters a `teams` construct. Each team is an initial team, and the initial thread in each team executes the team area.\n", diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb index 5f0f98f..dc8c947 100644 --- a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb @@ -33,7 +33,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/MultiCoreMultiCPU/plan.md b/src/MultiCoreMultiCPU/plan.md deleted file mode 100644 index ffc4632..0000000 --- a/src/MultiCoreMultiCPU/plan.md +++ /dev/null @@ -1,38 +0,0 @@ -Parallel Programming for Multicore and Multi-CPU Machines -========================================================= - -Temporary page indicating start of a section - - -# Parallel Programming for Multicore and Multi-CPU Machines - -## Introduction into Multicore and Multi-CPU machines - -Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. - - -## 1. Multicore and Multi-CPU shared memory systems. -Describe the architecture which can be considered as MIMD architecture. Each thread/core has its own execution context and program counter. All threads/core shared memory, which could be NUMA, etc.. -About 1-2 pages, have some figures for the multicore/multi-CPU shared memory systems. System approach of parallel programming for this architecture, e.g. using pthread. -Divide into paragraphs and identify the content for each paragraph -#### What are the Multi-core and multi-CPU architectures -#### Cache-coherent shared memory for multi-core and multi-CPU architecture, focusing on the NUMA aspect, shared memory aspect, and memory consistency model. The implication of shared memory to performance, e.g. false-sharing issue, memory bandwidth challenges, synchronization cost -#### PThread programming models used so far and for a long time. + and - of pthreads -#### Synchronization between threads and cores, e.g. mutual exclusion, etc - -MIMD architecture consists of processors that operate independently and asynchronously from one another. MIMD architecture systems consist of many processors that can have much common memory or memory that is exclusive to one. These terms mean many processes can execute instructions at any time with any piece or segment of data. MIMD architecture consists of two different types of architecture; Shared Memory MIMD architecture and Distributed Memory MIMD architecture. - -Shared Memory MIMD systems have the following characteristics. Shared Memory MIMD groups processors and memory. Any processor can access that memory through a communication channel designated by the programmer. Finally, the memory addresses are shared between processors. On the other hand, Distributed Memory MIMD systems have their own set of characteristics. One, memory and processors are grouped together in pairs known as processing elements. Which is linked to other PEs through the use of communication channels. Finally, each PE communicates with each other by sending messages, communication isn’t as open like that of a Shared Memory MIMD system. - - -## 2. Creating SPMD parallelism using OpenMP parallel and teams directive -#### Controlling number of threads and teams -#### Diverge the work for threads using mask directive and omp_get_thread_num -#### Synchronization of threads using barrier and order directive - -Open-MP allows for the creation of shared-memory parallel programs. In this Chapter, we will be discussing Single Program, Multiple Data, or SPMD for short. SPMD style uses a number of individual processors or threads to carry out the same program or computation on different sets of data simultaneously. SPMD style parallel programming is an example of a low-level thread-specific programming style. Which can be identified by the following characteristics: - - -## 3. Asynchronous tasking - -## 4. Explicit distribution of work using single, sections, workshring-loop, and distribute construct diff --git a/src/SomethingMayUsefulInFuture/build_rex.md b/src/SomethingMayUsefulInFuture/build_rex.md deleted file mode 100644 index 47bf64e..0000000 --- a/src/SomethingMayUsefulInFuture/build_rex.md +++ /dev/null @@ -1,126 +0,0 @@ -# Building REX - -## 1. Prerequisite - -### 1.1 OS: -Ubuntu 20.04 LTS with GNU 9.x and 7.x, Ubuntu 18.04 LTS with GNU 7.x, and Ubuntu 16.04.6 LTS with GNU 5.x were all tested - -### 1.2 Software: -```bash -sudo apt update && \ -sudo apt install -y openjdk-8-jdk && \ -sudo apt install -y \ - autoconf \ - automake \ - autotools-dev \ - bc \ - binutils \ - bison \ - build-essential \ - cmake \ - cpufrequtils \ - curl \ - device-tree-compiler \ - dkms \ - doxygen \ - flex \ - gawk \ - gcc-multilib \ - gdb \ - gfortran \ - ghostscript \ - git \ - gperf \ - graphviz \ - libboost-all-dev \ - libgmp-dev \ - libhpdf-dev \ - libmpc-dev \ - libmpfr-dev \ - libomp-dev \ - libtool \ - libxml2-dev \ - patchutils \ - perl-doc \ - python3-dev \ - sqlite \ - texinfo \ - unzip \ - vim \ - wget \ - zip \ - zlib1g \ - zlib1g-dev -``` - -### 1.3 Environment - -The compilation requires that `CC` and `CXX` point to the same compiler version. For example, it won't work if `CC=gcc-5` and `CXX=g++-7`. On each of our systems, we used the shipped compiler. - -```bash -export CC=/usr/bin/gcc -export CXX=/usr/bin/g++ -``` - -However, if you wish to use another version, or find it necessary to do so, you can repeat the steps above: - -```bash -export CC=/usr/bin/gcc-7 -export CXX=/usr/bin/g++-7 -``` - -So far OpenJDK 8 is tested. Even we remove the limit to JDK, other versions may not work as expected. - -```bash -export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64 -export LD_LIBRARY_PATH=$JAVA_HOME/jre/lib/amd64/server:$LD_LIBRARY_PATH -``` - -Assume we prepare a folder `$HOME/Projects/rexcompiler` for the compilation and installation. You could use other proper folder as well. -```bash -REX_ROOT=$HOME/Projects/rexcompiler -``` - -### 1.4 EDG and ompparser -EDG and ompparser are part of REX compiler as git submodules. Thus no separate installation are needed. - -## 2. REX Compiler - -```bash -cd $REX_ROOT -git clone git@github.com:passlab/rexompiler.git rex_src -mkdir rex_build -cd rex_src -git submodule update --init -./build -cd ../rex_build -../rex_src/configure --prefix=$REX_ROOT/rex_install --with-boost=/usr --with-boost-libdir=/usr/lib/x86_64-linux-gnu/ --enable-languages=c,c++,fortran --disable-tests-directory --disable-tutorial-directory -make core -j6 -make install-core -``` - -Now the compilation is completed and `REXCompiler` is installed in `$REX_ROOT/rex_install`. -```bash -export LD_LIBRARY_PATH=$REX_ROOT/rex_install/lib:$LD_LIBRARY_PATH -export PATH=$REX_ROOT/rex_install/bin:$PATH -``` - -## 3. Tests - -There are at least three locations we need to test, which are `/tests/nonsmoke/functional/CompileTests/OpenMP_tests`, `/tests/nonsmoke/functional/roseTests/astInterfaceTests`, and `/tests/nonsmoke/functional/roseTests/ompLoweringTests`. However, at this moment we only enable the tests in the first two locations because the last one hasn't been modified for `REXCompiler` yet. - -**The following tests should be passed locally before committing.** - -```bash -cd $REX_ROOT/rex_build/tests/nonsmoke/functional/CompileTests/OpenMP_tests -make check -cd $REX_ROOT/rex_build/tests/nonsmoke/functional/roseTests/astInterfaceTests -make check -``` - -## 4. Miscellaneous - -Please notice that GitHub supports two ways to access the code using `https/password` and `git/SSH key`. In this tutorial, the `git/SSH key` is used. To use the other method, all the `git` link should be replaced with the `https` link. Check [here](https://help.github.com/en/github/using-git/which-remote-url-should-i-use) for more details. - - - diff --git a/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv b/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv deleted file mode 100644 index 935914b..0000000 --- a/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatest1.csv +++ /dev/null @@ -1,2126 +0,0 @@ -cap-shape-bell,cap-shape-conical,cap-shape-convex,cap-shape-flat,cap-shape-knobbed,cap-shape-sunken,cap-surface-fibrous,cap-surface-grooves,cap-surface-scaly,cap-surface-smooth,cap-color-brown,cap-color-buff,cap-color-cinnamon,cap-color-gray,cap-color-green,cap-color-pink,cap-color-purple,cap-color-red,cap-color-white,cap-color-yellow,bruises?-bruises,odor-almond,odor-anise,odor-creosote,odor-fishy,odor-foul,odor-musty,odor-none,odor-pungent,odor-spicy,gill-attachment-attached,gill-attachment-descending,gill-attachment-free,gill-attachment-notched,gill-spacing-close,gill-spacing-crowded,gill-spacing-distant,gill-size-broad,gill-color-black,gill-color-brown,gill-color-buff,gill-color-chocolate,gill-color-gray,gill-color-green,gill-color-orange,gill-color-pink,gill-color-purple,gill-color-red,gill-color-white,gill-color-yellow,stalk-shape-enlarging,stalk-root-bulbous,stalk-root-club,stalk-root-cup,stalk-root-equal,stalk-root-rhizomorphs,stalk-root-rooted,stalk-root-missing,stalk-surface-above-ring-fibrous,stalk-surface-above-ring-scaly,stalk-surface-above-ring-silky,stalk-surface-above-ring-smooth,stalk-surface-below-ring-fibrous,stalk-surface-below-ring-scaly,stalk-surface-below-ring-silky,stalk-surface-below-ring-smooth,stalk-color-above-ring-brown,stalk-color-above-ring-buff,stalk-color-above-ring-cinnamon,stalk-color-above-ring-gray,stalk-color-above-ring-orange,stalk-color-above-ring-pink,stalk-color-above-ring-red,stalk-color-above-ring-white,stalk-color-above-ring-yellow,stalk-color-below-ring-brown,stalk-color-below-ring-buff,stalk-color-below-ring-cinnamon,stalk-color-below-ring-gray,stalk-color-below-ring-orange,stalk-color-below-ring-pink,stalk-color-below-ring-red,stalk-color-below-ring-white,stalk-color-below-ring-yellow,veil-type-partial,veil-color-brown,veil-color-orange,veil-color-white,veil-color-yellow,ring-number-none,ring-number-one,ring-number-two,ring-type-cobwebby,ring-type-evanescent,ring-type-flaring,ring-type-large,ring-type-none,ring-type-pendant,ring-type-sheathing,ring-type-zone,spore-print-color-black,spore-print-color-brown,spore-print-color-buff,spore-print-color-chocolate,spore-print-color-green,spore-print-color-orange,spore-print-color-purple,spore-print-color-white,spore-print-color-yellow,population-abundant,population-clustered,population-numerous,population-scattered,population-several,population-solitary,habitat-grasses,habitat-leaves,habitat-meadows,habitat-paths,habitat-urban,habitat-waste,habitat-woods,poisonous -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0 diff --git a/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv b/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv deleted file mode 100644 index 8ee61e2..0000000 --- a/src/SomethingMayUsefulInFuture/decision_tree/agaricuslepiotatrain1.csv +++ /dev/null @@ -1,6001 +0,0 @@ -cap-shape-bell,cap-shape-conical,cap-shape-convex,cap-shape-flat,cap-shape-knobbed,cap-shape-sunken,cap-surface-fibrous,cap-surface-grooves,cap-surface-scaly,cap-surface-smooth,cap-color-brown,cap-color-buff,cap-color-cinnamon,cap-color-gray,cap-color-green,cap-color-pink,cap-color-purple,cap-color-red,cap-color-white,cap-color-yellow,bruises?-bruises,odor-almond,odor-anise,odor-creosote,odor-fishy,odor-foul,odor-musty,odor-none,odor-pungent,odor-spicy,gill-attachment-attached,gill-attachment-descending,gill-attachment-free,gill-attachment-notched,gill-spacing-close,gill-spacing-crowded,gill-spacing-distant,gill-size-broad,gill-color-black,gill-color-brown,gill-color-buff,gill-color-chocolate,gill-color-gray,gill-color-green,gill-color-orange,gill-color-pink,gill-color-purple,gill-color-red,gill-color-white,gill-color-yellow,stalk-shape-enlarging,stalk-root-bulbous,stalk-root-club,stalk-root-cup,stalk-root-equal,stalk-root-rhizomorphs,stalk-root-rooted,stalk-root-missing,stalk-surface-above-ring-fibrous,stalk-surface-above-ring-scaly,stalk-surface-above-ring-silky,stalk-surface-above-ring-smooth,stalk-surface-below-ring-fibrous,stalk-surface-below-ring-scaly,stalk-surface-below-ring-silky,stalk-surface-below-ring-smooth,stalk-color-above-ring-brown,stalk-color-above-ring-buff,stalk-color-above-ring-cinnamon,stalk-color-above-ring-gray,stalk-color-above-ring-orange,stalk-color-above-ring-pink,stalk-color-above-ring-red,stalk-color-above-ring-white,stalk-color-above-ring-yellow,stalk-color-below-ring-brown,stalk-color-below-ring-buff,stalk-color-below-ring-cinnamon,stalk-color-below-ring-gray,stalk-color-below-ring-orange,stalk-color-below-ring-pink,stalk-color-below-ring-red,stalk-color-below-ring-white,stalk-color-below-ring-yellow,veil-type-partial,veil-color-brown,veil-color-orange,veil-color-white,veil-color-yellow,ring-number-none,ring-number-one,ring-number-two,ring-type-cobwebby,ring-type-evanescent,ring-type-flaring,ring-type-large,ring-type-none,ring-type-pendant,ring-type-sheathing,ring-type-zone,spore-print-color-black,spore-print-color-brown,spore-print-color-buff,spore-print-color-chocolate,spore-print-color-green,spore-print-color-orange,spore-print-color-purple,spore-print-color-white,spore-print-color-yellow,population-abundant,population-clustered,population-numerous,population-scattered,population-several,population-solitary,habitat-grasses,habitat-leaves,habitat-meadows,habitat-paths,habitat-urban,habitat-waste,habitat-woods,poisonous -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1 -1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1 -0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1 -0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0 -0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0 -0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1 -0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1 diff --git a/src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb b/src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb deleted file mode 100644 index 331c9fb..0000000 --- a/src/SomethingMayUsefulInFuture/decision_tree/decision_tree.ipynb +++ /dev/null @@ -1,696 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Decision Tree" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisite" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import re\n", - "import pandas as pd;\n", - "import math\n", - "from sklearn.tree import DecisionTreeClassifier as dt\n", - "from sklearn.tree import plot_tree\n", - "import matplotlib" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basic Classes" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "class Node:\n", - " \"\"\" Node class for a decision tree. \"\"\"\n", - " def __init__(self, names):\n", - " self.names = names\n", - "\n", - " def classify(x):\n", - " \"\"\" Handled by the subclasses. \"\"\"\n", - " return None\n", - "\n", - " def dump(self, indent):\n", - " \"\"\" Handled by the subclasses. \"\"\"\n", - " return None\n", - "\n", - "\n", - "class Leaf(Node):\n", - " def __init__(self, names, value):\n", - " Node.__init__(self, names)\n", - " self.value = value\n", - "\n", - " def classify(self, x):\n", - " return self.value\n", - "\n", - " def dump(self, indent):\n", - " print(' %d' % self.value)\n", - "\n", - "\n", - "class Split(Node):\n", - " def __init__(self, names, var, left, right):\n", - " Node.__init__(self, names)\n", - " self.var = var\n", - " self.left = left\n", - " self.right = right\n", - "\n", - " def classify(self, x):\n", - " if x[self.var] == 0:\n", - " return self.left.classify(x)\n", - " else:\n", - " return self.right.classify(x)\n", - " \n", - " def dump(self, indent):\n", - " if indent > 0:\n", - " print('')\n", - " for i in range(0, indent):\n", - " print('| ', end='')\n", - " print('%s = 0 :' % self.names[self.var],end='')\n", - " self.left.dump(indent+1)\n", - " for i in range(0, indent):\n", - " print('| ', end='')\n", - " print('%s = 1 :' % self.names[self.var],end='')\n", - " self.right.dump(indent+1)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Helper function computes entropy of Bernoulli distribution with parameter p" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def entropy(p):\n", - "\n", - " if p == 0 or p == 1:\n", - " return 0\n", - " \n", - " result = -(p * math.log2(p) + (1 - p) * math.log2(1 - p))\n", - " \n", - " return result;\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Compute information gain for a particular split, given the counts \n", - "\n", - "py_pxi : number of occurences of y=1 with x_i=1 for all i=1 to n\n", - "\n", - "pxi : number of occurrences of x_i=1\n", - "\n", - "py : number of ocurrences of y=1\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def infogain(py_pxi, pxi, py, total):\n", - "\n", - " Hs = entropy(py/total)\n", - " if pxi == 0:\n", - " H1 = 0\n", - " else:\n", - " H1 = entropy(py_pxi/pxi)\n", - " if pxi == total:\n", - " H0 = 0\n", - " else:\n", - " H0 = entropy((py - py_pxi)/(total - pxi))\n", - " result = Hs - (pxi/total) * H1 - ((total - pxi)/total) * H0\n", - " \n", - " return result;\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OTHER SUGGESTED HELPER FUNCTIONS:\n", - "\n", - "-collect counts for each variable value with each class label\n", - "\n", - "-find the best variable to split on, according to mutual information\n", - "\n", - "-partition data based on a given variable\t\n", - "\t\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Load data from a file\n", - "def read_data(filename):\n", - " f = open(filename, 'r')\n", - " p = re.compile(',')\n", - " data = []\n", - " header = f.readline().strip()\n", - " varnames = p.split(header)\n", - " namehash = {}\n", - " for l in f:\n", - " data.append([int(x) for x in p.split(l.strip())])\n", - " return (data, varnames)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Build tree in a top-down manner, selecting splits until we hit a pure leaf or all splits look bad.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def build_tree(data, varnames):\n", - " \n", - " dataSize = len(data)\n", - " \n", - " # if there's only one class left, the current node will be a leaf node\n", - " py = 0\n", - " for v in data:\n", - " if v[-1] == 1:\n", - " py += 1\n", - " if py == 0:\n", - " return Leaf(varnames, 0)\n", - " elif py == dataSize:\n", - " return Leaf(varnames, 1)\n", - "\n", - " \n", - " # otherwise, the different info gains will be checked\n", - " maxGain = -1\n", - " maxFeatureIndex = -1\n", - "\n", - " for i in range(len(varnames) - 1):\n", - " if varnames[i] != None:\n", - " py_pxi = 0\n", - " pxi = 0\n", - " py = 0\n", - " for v in data:\n", - " if v[i] == 0:\n", - " if v[-1] == 1:\n", - " py += 1\n", - " else:\n", - " if v[-1] == 1:\n", - " py_pxi += 1\n", - " py += 1\n", - " pxi += 1\n", - " # calculate the info gain based on the current feature, and update the maximum info gain and corresponding feature index\n", - " currentGain = infogain(py_pxi, pxi, py, dataSize)\n", - " if currentGain > maxGain:\n", - " maxGain = currentGain\n", - " maxFeatureIndex = i\n", - " \n", - " # divide the data set based on the selected feature\n", - " leftData = []\n", - " rightData = []\n", - " \n", - " for v in data:\n", - " if v[maxFeatureIndex] == 0:\n", - " leftData.append(v)\n", - " else:\n", - " rightData.append(v)\n", - " \n", - " # disable the features that have been checked\n", - " leftNames = varnames.copy()\n", - " rightNames = varnames.copy()\n", - " leftNames[maxFeatureIndex] = None\n", - " rightNames[maxFeatureIndex] = None\n", - " \n", - " # build the subtrees\n", - " leftNode = build_tree(leftData, leftNames)\n", - " rightNode = build_tree(rightData, rightNames)\n", - " # return the current node after building the subtrees\n", - " return Split(varnames, maxFeatureIndex, leftNode, rightNode)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Main Program" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we load data.\n", - "Each example is a list of attribute values, where the last element in the list is the class value.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "(train, varnames) = read_data('agaricuslepiotatrain1.csv')\n", - "(test, testvarnames) = read_data('agaricuslepiotatest1.csv')\n", - "#(train, varnames) = read_data('training_set.csv')\n", - "#(test, testvarnames) = read_data('test_set.csv') " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    0123456789...113114115116117118119120121122
    00010000001...0000001001
    10010000001...0010000000
    21000000001...0000100000
    30010000010...0000001001
    40010000001...0010000000
    \n", - "

    5 rows × 123 columns

    \n", - "
    " - ], - "text/plain": [ - " 0 1 2 3 4 5 6 7 8 9 ... 113 114 115 116 \\\n", - "0 0 0 1 0 0 0 0 0 0 1 ... 0 0 0 0 \n", - "1 0 0 1 0 0 0 0 0 0 1 ... 0 0 1 0 \n", - "2 1 0 0 0 0 0 0 0 0 1 ... 0 0 0 0 \n", - "3 0 0 1 0 0 0 0 0 1 0 ... 0 0 0 0 \n", - "4 0 0 1 0 0 0 0 0 0 1 ... 0 0 1 0 \n", - "\n", - " 117 118 119 120 121 122 \n", - "0 0 0 1 0 0 1 \n", - "1 0 0 0 0 0 0 \n", - "2 1 0 0 0 0 0 \n", - "3 0 0 1 0 0 1 \n", - "4 0 0 0 0 0 0 \n", - "\n", - "[5 rows x 123 columns]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.DataFrame(train).head()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "#varnames" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "# use sklearn library for comparison\n", - "clf = dt(criterion='entropy', splitter='best', max_depth=5)\n", - "train_x = []\n", - "train_y = []\n", - "for v in train:\n", - " train_x.append(v[:-1])\n", - " train_y.append(v[-1])\n", - "clf.fit(train_x, train_y)\n", - "test_x = []\n", - "test_y = []\n", - "for v in test:\n", - " test_x.append(v[:-1])\n", - " test_y.append(v[-1])\n", - "plot_tree(clf)\n", - "\n", - "acc = 0\n", - "pred = clf.predict(test_x)\n", - "for i in range(len(pred)):\n", - " if pred[i] == test_y[i]:\n", - " acc += 1\n", - "print(acc/len(test_x))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Build the decision tree" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "root = build_tree(train, varnames)" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "Draw the tree.\n", - "\n", - "\n", - "Sample more for mushroom:\n", - "odor-foul = 0 :\n", - "| gill-size-narrow = 0 :\n", - "| | spore-print-color-green = 0 : 0\n", - "| | spore-print-color-green = 1 : 1\n", - "| gill-size-narrow = 1 :\n", - "| | odor-none = 0 :\n", - "| | | gill-spacing-close = 0 :\n", - "| | | | bruises?-bruises = 0 : 1\n", - "| | | | bruises?-bruises = 1 : 0\n", - "| | | gill-spacing-close = 1 : 1\n", - "| | odor-none = 1 :\n", - "| | | stalk-surface-above-ring-silky = 0 :\n", - "| | | | bruises?-bruises = 0 : 0\n", - "| | | | bruises?-bruises = 1 : 1\n", - "| | | stalk-surface-above-ring-silky = 1 : 1\n", - "odor-foul = 1 : 1\n", - "\n", - "According to this model if odor-foul is 0 and gill-size-narrow = 0 and spore-print-color-green is 1 then predicted class is one." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "odor-foul = 0 :\n", - "| gill-size-broad = 0 :\n", - "| | odor-none = 0 :\n", - "| | | gill-spacing-close = 0 :\n", - "| | | | bruises?-bruises = 0 : 1\n", - "| | | | bruises?-bruises = 1 : 0\n", - "| | | gill-spacing-close = 1 : 1\n", - "| | odor-none = 1 :\n", - "| | | stalk-surface-above-ring-silky = 0 :\n", - "| | | | bruises?-bruises = 0 : 0\n", - "| | | | bruises?-bruises = 1 : 1\n", - "| | | stalk-surface-above-ring-silky = 1 : 1\n", - "| gill-size-broad = 1 :\n", - "| | spore-print-color-green = 0 : 0\n", - "| | spore-print-color-green = 1 : 1\n", - "odor-foul = 1 : 1\n" - ] - } - ], - "source": [ - "root.dump(0)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Calcuating the accuracy" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def accuracy(data):\n", - " correct = 0\n", - " # The position of the class label is the last element in the list.\n", - " yi = len(data[0]) - 1\n", - " for x in data:\n", - " # Classification is done recursively by the node class.\n", - " # This should work as-is.\n", - " pred = root.classify(x)\n", - " if pred == x[yi]:\n", - " correct += 1\n", - " acc = float(correct)/len(data)\n", - " return acc;\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Results" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train Accuracy: 1.0\n" - ] - } - ], - "source": [ - " print(\"Train Accuracy: {}\".format(accuracy(train)))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Test Accuracy: 0.9792941176470589\n" - ] - } - ], - "source": [ - " print(\"Test Accuracy: {}\".format(accuracy(test)))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.1" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/src/SomethingMayUsefulInFuture/logo.png b/src/SomethingMayUsefulInFuture/logo.png deleted file mode 100644 index 06d56f40c838b64eb048a63e036125964a069a3a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9854 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 L>8MsHTOs~GC;Fmw diff --git a/src/SomethingMayUsefulInFuture/markdown.md b/src/SomethingMayUsefulInFuture/markdown.md deleted file mode 100644 index 1cc9c34..0000000 --- a/src/SomethingMayUsefulInFuture/markdown.md +++ /dev/null @@ -1,125 +0,0 @@ -# Markdown Files - -Whether you write your book's content in Jupyter Notebooks (`.ipynb`) or -in regular markdown files (`.md`), you'll write in the same flavor of markdown -called **MyST Markdown**. - -## What is MyST? - -MyST stands for "Markedly Structured Text". It -is a slight variation on a flavor of markdown called "CommonMark" markdown, -with small syntax extensions to allow you to write **roles** and **directives** -in the Sphinx ecosystem. - -## What are roles and directives? - -Roles and directives are two of the most powerful tools in Jupyter Book. They -are kind of like functions, but written in a markup language. They both -serve a similar purpose, but **roles are written in one line**, whereas -**directives span many lines**. They both accept different kinds of inputs, -and what they do with those inputs depends on the specific role or directive -that is being called. - -### Using a directive - -At its simplest, you can insert a directive into your book's content like so: - -```` -```{mydirectivename} -My directive content -``` -```` - -This will only work if a directive with name `mydirectivename` already exists -(which it doesn't). There are many pre-defined directives associated with -Jupyter Book. For example, to insert a note box into your content, you can -use the following directive: - -```` -```{note} -Here is a note -``` -```` - -This results in: - -```{note} -Here is a note -``` - -In your built book. - -For more information on writing directives, see the -[MyST documentation](https://myst-parser.readthedocs.io/). - - -### Using a role - -Roles are very similar to directives, but they are less-complex and written -entirely on one line. You can insert a role into your book's content with -this pattern: - -``` -Some content {rolename}`and here is my role's content!` -``` - -Again, roles will only work if `rolename` is a valid role's name. For example, -the `doc` role can be used to refer to another page in your book. You can -refer directly to another page by its relative path. For example, the -role syntax `` {doc}`intro` `` will result in: {doc}`intro`. - -For more information on writing roles, see the -[MyST documentation](https://myst-parser.readthedocs.io/). - - -### Adding a citation - -You can also cite references that are stored in a `bibtex` file. For example, -the following syntax: `` {cite}`holdgraf_evidence_2014` `` will render like -this: {cite}`holdgraf_evidence_2014`. - -Moreoever, you can insert a bibliography into your page with this syntax: -The `{bibliography}` directive must be used for all the `{cite}` roles to -render properly. -For example, if the references for your book are stored in `references.bib`, -then the bibliography is inserted with: - -```` -```{bibliography} -``` -```` - -Resulting in a rendered bibliography that looks like: - -```{bibliography} -``` - - -### Executing code in your markdown files - -If you'd like to include computational content inside these markdown files, -you can use MyST Markdown to define cells that will be executed when your -book is built. Jupyter Book uses *jupytext* to do this. - -First, add Jupytext metadata to the file. For example, to add Jupytext metadata -to this markdown page, run this command: - -``` -jupyter-book myst init markdown.md -``` - -Once a markdown file has Jupytext metadata in it, you can add the following -directive to run the code at build time: - -```` -```{code-cell} -print("Here is some code to execute") -``` -```` - -When your book is built, the contents of any `{code-cell}` blocks will be -executed with your default Jupyter kernel, and their outputs will be displayed -in-line with the rest of your content. - -For more information about executing computational content with Jupyter Book, -see [The MyST-NB documentation](https://myst-nb.readthedocs.io/). diff --git a/src/SomethingMayUsefulInFuture/notebooks.ipynb b/src/SomethingMayUsefulInFuture/notebooks.ipynb deleted file mode 100644 index c97c5e4..0000000 --- a/src/SomethingMayUsefulInFuture/notebooks.ipynb +++ /dev/null @@ -1,122 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Content with notebooks\n", - "\n", - "You can also create content with Jupyter Notebooks. This means that you can include\n", - "code blocks and their outputs in your book.\n", - "\n", - "## Markdown + notebooks\n", - "\n", - "As it is markdown, you can embed images, HTML, etc into your posts!\n", - "\n", - "![](https://myst-parser.readthedocs.io/en/latest/_static/logo.png)\n", - "\n", - "You an also $add_{math}$ and\n", - "\n", - "$$\n", - "math^{blocks}\n", - "$$\n", - "\n", - "or\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "\\mbox{mean} la_{tex} \\\\ \\\\\n", - "math blocks\n", - "\\end{aligned}\n", - "$$\n", - "\n", - "But make sure you \\$Escape \\$your \\$dollar signs \\$you want to keep!\n", - "\n", - "## MyST markdown\n", - "\n", - "MyST markdown works in Jupyter Notebooks as well. For more information about MyST markdown, check\n", - "out [the MyST guide in Jupyter Book](https://jupyterbook.org/content/myst.html),\n", - "or see [the MyST markdown documentation](https://myst-parser.readthedocs.io/en/latest/).\n", - "\n", - "## Code blocks and outputs\n", - "\n", - "Jupyter Book will also embed your code blocks and output in your book.\n", - "For example, here's some sample Matplotlib code:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib import rcParams, cycler\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "plt.ion()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Fixing random state for reproducibility\n", - "np.random.seed(19680801)\n", - "\n", - "N = 10\n", - "data = [np.logspace(0, 1, 100) + np.random.randn(100) + ii for ii in range(N)]\n", - "data = np.array(data).T\n", - "cmap = plt.cm.coolwarm\n", - "rcParams['axes.prop_cycle'] = cycler(color=cmap(np.linspace(0, 1, N)))\n", - "\n", - "\n", - "from matplotlib.lines import Line2D\n", - "custom_lines = [Line2D([0], [0], color=cmap(0.), lw=4),\n", - " Line2D([0], [0], color=cmap(.5), lw=4),\n", - " Line2D([0], [0], color=cmap(1.), lw=4)]\n", - "\n", - "fig, ax = plt.subplots(figsize=(10, 5))\n", - "lines = ax.plot(data)\n", - "ax.legend(custom_lines, ['Cold', 'Medium', 'Hot']);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There is a lot more that you can do with outputs (such as including interactive outputs)\n", - "with your book. For more information about this, see [the Jupyter Book documentation](https://jupyterbook.org)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/src/SomethingMayUsefulInFuture/preface.md b/src/SomethingMayUsefulInFuture/preface.md deleted file mode 100644 index 0818409..0000000 --- a/src/SomethingMayUsefulInFuture/preface.md +++ /dev/null @@ -1,2 +0,0 @@ -## Preface -====== diff --git a/src/_toc.yml b/src/_toc.yml index 2c369f7..822992b 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -11,11 +11,11 @@ parts: - file: preface - numbered: True chapters: - - file: Ch1_openmpIntro + - file: Ch1_OpenmpIntro sections: - - file: openmp_c/1_IntroductionOfOpenMP.ipynb - - file: openmp_c/2_Syntax.ipynb - - file: openmp_c/3_performance.ipynb + - file: Openmp_C/1_IntroductionOfOpenMP.ipynb + - file: Openmp_C/2_Syntax.ipynb + - file: Openmp_C/3_Performance.ipynb - file: Ch2_MulticoreMultiCPU sections: - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -24,8 +24,11 @@ parts: - file: MultiCoreMultiCPU/4_SynchronizationThreads.ipynb - file: MultiCoreMultiCPU/5_AsynchronousTasking.ipynb - file: MultiCoreMultiCPU/6_ExplicitDistribution.ipynb - - file: Ch3_SIMDVector + - file: Ch3_SIMDVector + sections: + - file: SIMDandVectorArchitecture/plan.md - file: Ch4_GPUAccel - sections: + sections: + - file: GPUAccelerators/1_architecture.ipynb - file: GPUAccelerators/1_DataMapping.ipynb - - file: GPUAccelerators/2_Metadirective.ipynb \ No newline at end of file + - file: GPUAccelerators/2_Metadirective.ipynb diff --git a/src/book_intro.md b/src/book_intro.md index f4792d3..bbe83b2 100644 --- a/src/book_intro.md +++ b/src/book_intro.md @@ -1 +1,2 @@ +# Introduction This is a brief introduction to give you a feel for how book content is structured. diff --git a/src/openmp_c/1_IntroductionOfOpenMP.ipynb b/src/openmp_c/1_IntroductionOfOpenMP.ipynb index 47bf501..84b1532 100644 --- a/src/openmp_c/1_IntroductionOfOpenMP.ipynb +++ b/src/openmp_c/1_IntroductionOfOpenMP.ipynb @@ -85,14 +85,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/openmp_c/2_Syntax.ipynb b/src/openmp_c/2_Syntax.ipynb index f6fc8ac..217877f 100644 --- a/src/openmp_c/2_Syntax.ipynb +++ b/src/openmp_c/2_Syntax.ipynb @@ -187,14 +187,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/openmp_c/3_performance.ipynb b/src/openmp_c/3_performance.ipynb index a56726f..a11af09 100644 --- a/src/openmp_c/3_performance.ipynb +++ b/src/openmp_c/3_performance.ipynb @@ -74,7 +74,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/openmp_c/parallel_for.ipynb b/src/openmp_c/parallel_for.ipynb deleted file mode 100644 index 36a33ff..0000000 --- a/src/openmp_c/parallel_for.ipynb +++ /dev/null @@ -1,301 +0,0 @@ -{ - "cells": [ - { - "cell_type": "raw", - "id": "15a76a54-74a2-4d86-8796-b90556a99127", - "metadata": {}, - "source": [ - "# `parallel for`" - ] - }, - { - "cell_type": "markdown", - "id": "plastic-innocent", - "metadata": {}, - "source": [ - "A simple example using OpenMP `parallel for` directive:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "beginning-exhibition", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Thread: 3, i = 6\n", - "Thread: 2, i = 4\n", - "Thread: 3, i = 7\n", - "Thread: 2, i = 5\n", - "Thread: 0, i = 0\n", - "Thread: 1, i = 2\n", - "Thread: 4, i = 8\n", - "Thread: 5, i = 10\n", - "Thread: 5, i = 11\n", - "Thread: 4, i = 9\n", - "Thread: 0, i = 1\n", - "Thread: 1, i = 3\n" - ] - } - ], - "source": [ - "//%compiler: clang\n", - "//%cflags: -fopenmp\n", - "\n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "int main (int argc, char** argv) {\n", - " int i;\n", - " #pragma omp parallel for num_threads(6)\n", - " for (i = 0; i < 12; i++)\n", - " printf(\"Thread: %d, i = %d\\n\", omp_get_thread_num(), i);\n", - " \n", - " return 0;\n", - " \n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2cbe28a5-303a-4218-a8e2-28140a0a2bf2", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/tmpvmwsz6j0.c: In function ‘read_timer’:\n", - "/tmp/tmpvmwsz6j0.c:14:5: warning: ‘ftime’ is deprecated [-Wdeprecated-declarations]\n", - " 14 | ftime(&tm);\n", - " | ^~~~~\n", - "In file included from /tmp/tmpvmwsz6j0.c:9:\n", - "/usr/include/x86_64-linux-gnu/sys/timeb.h:39:12: note: declared here\n", - " 39 | extern int ftime (struct timeb *__timebuf)\n", - " | ^~~~~\n", - "/tmp/tmpvmwsz6j0.c: In function ‘read_timer_ms’:\n", - "/tmp/tmpvmwsz6j0.c:21:5: warning: ‘ftime’ is deprecated [-Wdeprecated-declarations]\n", - " 21 | ftime(&tm);\n", - " | ^~~~~\n", - "In file included from /tmp/tmpvmwsz6j0.c:9:\n", - "/usr/include/x86_64-linux-gnu/sys/timeb.h:39:12: note: declared here\n", - " 39 | extern int ftime (struct timeb *__timebuf)\n", - " | ^~~~~\n", - "Usage: sum (default 102400)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "======================================================================================================\n", - "\tSum 102400 numbers\n", - "------------------------------------------------------------------------------------------------------\n", - "Performance:\t\tRuntime (ms)\t MFLOPS \n", - "------------------------------------------------------------------------------------------------------\n", - "Sum:\t\t\t0.000000\t inf\n" - ] - } - ], - "source": [ - "//%load https://passlab.github.io/ITSC3181/exercises/sum/sum_full.c\n", - "/*\n", - " * Sum of a*X[N]\n", - " */\n", - "#include \n", - "#include \n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "/* read timer in second */\n", - "double read_timer() {\n", - " struct timeb tm;\n", - " ftime(&tm);\n", - " return (double) tm.time + (double) tm.millitm / 1000.0;\n", - "}\n", - "\n", - "/* read timer in ms */\n", - "double read_timer_ms() {\n", - " struct timeb tm;\n", - " ftime(&tm);\n", - " return (double) tm.time * 1000.0 + (double) tm.millitm;\n", - "}\n", - "\n", - "#define REAL float\n", - "#define VECTOR_LENGTH 102400\n", - "\n", - "/* initialize a vector with random floating point numbers */\n", - "void init(REAL A[], int N) {\n", - " int i;\n", - " for (i = 0; i < N; i++) {\n", - " A[i] = (double) drand48();\n", - " }\n", - "}\n", - "\n", - "REAL sum(int N, REAL X[], REAL a) {\n", - " int i;\n", - " REAL result = 0.0;\n", - " for (i = 0; i < N; ++i)\n", - " result += a * X[i];\n", - " return result;\n", - "}\n", - "\n", - "int main(int argc, char *argv[]) {\n", - " int N = VECTOR_LENGTH;\n", - " double elapsed; /* for timing */\n", - " if (argc < 2) {\n", - " fprintf(stderr, \"Usage: sum (default %d)\\n\", N);\n", - " } else N = atoi(argv[1]);\n", - " REAL *X = (REAL*)malloc(sizeof(REAL)*N);\n", - " REAL *Y = (REAL*)malloc(sizeof(REAL)*N);\n", - "\n", - " srand48((1 << 12));\n", - " init(X, N);\n", - " init(Y, N);\n", - " REAL a = 0.1234;\n", - " /* example run */\n", - " elapsed = read_timer();\n", - " REAL result = sum(N, X, a);\n", - " elapsed = (read_timer() - elapsed);\n", - " printf(\"======================================================================================================\\n\");\n", - " printf(\"\\tSum %d numbers\\n\", N);\n", - " printf(\"------------------------------------------------------------------------------------------------------\\n\");\n", - " printf(\"Performance:\\t\\tRuntime (ms)\\t MFLOPS \\n\");\n", - " printf(\"------------------------------------------------------------------------------------------------------\\n\");\n", - " printf(\"Sum:\\t\\t\\t%4f\\t%4f\\n\", elapsed * 1.0e3, 2*N / (1.0e6 * elapsed));\n", - " return 0;\n", - "}\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a2404bb2-27e3-4290-99d8-87a656d485a2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Hello from process: 0\n", - " Hello from process: 7\n", - " Hello from process: 15\n", - " Hello from process: 19\n", - " Hello from process: 6\n", - " Hello from process: 71\n", - " Hello from process: 34\n", - " Hello from process: 67\n", - " Hello from process: 20\n", - " Hello from process: 45\n", - " Hello from process: 44\n", - " Hello from process: 5\n", - " Hello from process: 47\n", - " Hello from process: 46\n", - " Hello from process: 56\n", - " Hello from process: 61\n", - " Hello from process: 64\n", - " Hello from process: 65\n", - " Hello from process: 14\n", - " Hello from process: 37\n", - " Hello from process: 60\n", - " Hello from process: 36\n", - " Hello from process: 51\n", - " Hello from process: 68\n", - " Hello from process: 57\n", - " Hello from process: 70\n", - " Hello from process: 2\n", - " Hello from process: 49\n", - " Hello from process: 43\n", - " Hello from process: 50\n", - " Hello from process: 25\n", - " Hello from process: 55\n", - " Hello from process: 40\n", - " Hello from process: 53\n", - " Hello from process: 16\n", - " Hello from process: 30\n", - " Hello from process: 52\n", - " Hello from process: 31\n", - " Hello from process: 59\n", - " Hello from process: 33\n", - " Hello from process: 9\n", - " Hello from process: 8\n", - " Hello from process: 41\n", - " Hello from process: 27\n", - " Hello from process: 11\n", - " Hello from process: 32\n", - " Hello from process: 24\n", - " Hello from process: 42\n", - " Hello from process: 63\n", - " Hello from process: 35\n", - " Hello from process: 3\n", - " Hello from process: 1\n", - " Hello from process: 23\n", - " Hello from process: 10\n", - " Hello from process: 66\n", - " Hello from process: 38\n", - " Hello from process: 28\n", - " Hello from process: 21\n", - " Hello from process: 69\n", - " Hello from process: 39\n", - " Hello from process: 4\n", - " Hello from process: 29\n", - " Hello from process: 13\n", - " Hello from process: 22\n", - " Hello from process: 48\n", - " Hello from process: 62\n", - " Hello from process: 58\n", - " Hello from process: 12\n", - " Hello from process: 54\n", - " Hello from process: 18\n", - " Hello from process: 26\n", - " Hello from process: 17\n" - ] - } - ], - "source": [ - "!!%compiler: gfortran\n", - "!!%cflags: -fopenmp\n", - "\n", - "PROGRAM Parallel_Hello_World\n", - "USE OMP_LIB\n", - "\n", - "!$OMP PARALLEL\n", - "\n", - " PRINT *, \"Hello from process: \", OMP_GET_THREAD_NUM()\n", - "\n", - "!$OMP END PARALLEL\n", - "\n", - "END" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "70810ace-4201-4540-bb28-21aa74b74bf4", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Native", - "language": "native", - "name": "native" - }, - "language_info": { - "file_extension": ".c", - "mimetype": "text/plain", - "name": "c" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From e749a4e1c22f4b025f95614354a73fe0a5483fad Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 21 Apr 2024 19:06:07 -0400 Subject: [PATCH 60/91] Fixed more warinings --- src/{Ch1_openmpIntro.md => Ch1_OpenmpIntro.md} | 0 src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb | 8 ++++---- src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb | 2 +- src/{openmp_c => Openmp_C}/0_13209261094r4F.png | Bin src/{openmp_c => Openmp_C}/1.png | Bin .../1_IntroductionOfOpenMP.ipynb | 0 src/{openmp_c => Openmp_C}/20190720101130709.png | Bin src/{openmp_c => Openmp_C}/2_Syntax.ipynb | 0 .../3_Performance.ipynb} | 0 9 files changed, 5 insertions(+), 5 deletions(-) rename src/{Ch1_openmpIntro.md => Ch1_OpenmpIntro.md} (100%) rename src/{openmp_c => Openmp_C}/0_13209261094r4F.png (100%) rename src/{openmp_c => Openmp_C}/1.png (100%) rename src/{openmp_c => Openmp_C}/1_IntroductionOfOpenMP.ipynb (100%) rename src/{openmp_c => Openmp_C}/20190720101130709.png (100%) rename src/{openmp_c => Openmp_C}/2_Syntax.ipynb (100%) rename src/{openmp_c/3_performance.ipynb => Openmp_C/3_Performance.ipynb} (100%) diff --git a/src/Ch1_openmpIntro.md b/src/Ch1_OpenmpIntro.md similarity index 100% rename from src/Ch1_openmpIntro.md rename to src/Ch1_OpenmpIntro.md diff --git a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb index a0e35c8..0cd8330 100644 --- a/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb +++ b/src/MultiCoreMultiCPU/1_MIMDArchitecture.ipynb @@ -130,9 +130,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + "display_name": "Native", + "language": "native", + "name": "native" }, "language_info": { "codemirror_mode": { @@ -144,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb index 735e83b..0cf54fa 100644 --- a/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb +++ b/src/MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb @@ -821,7 +821,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.8.10" }, "toc-showcode": false }, diff --git a/src/openmp_c/0_13209261094r4F.png b/src/Openmp_C/0_13209261094r4F.png similarity index 100% rename from src/openmp_c/0_13209261094r4F.png rename to src/Openmp_C/0_13209261094r4F.png diff --git a/src/openmp_c/1.png b/src/Openmp_C/1.png similarity index 100% rename from src/openmp_c/1.png rename to src/Openmp_C/1.png diff --git a/src/openmp_c/1_IntroductionOfOpenMP.ipynb b/src/Openmp_C/1_IntroductionOfOpenMP.ipynb similarity index 100% rename from src/openmp_c/1_IntroductionOfOpenMP.ipynb rename to src/Openmp_C/1_IntroductionOfOpenMP.ipynb diff --git a/src/openmp_c/20190720101130709.png b/src/Openmp_C/20190720101130709.png similarity index 100% rename from src/openmp_c/20190720101130709.png rename to src/Openmp_C/20190720101130709.png diff --git a/src/openmp_c/2_Syntax.ipynb b/src/Openmp_C/2_Syntax.ipynb similarity index 100% rename from src/openmp_c/2_Syntax.ipynb rename to src/Openmp_C/2_Syntax.ipynb diff --git a/src/openmp_c/3_performance.ipynb b/src/Openmp_C/3_Performance.ipynb similarity index 100% rename from src/openmp_c/3_performance.ipynb rename to src/Openmp_C/3_Performance.ipynb From abffa37340d3c13d6eb7c1c10d2725d2b93a0957 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 21 Apr 2024 20:56:35 -0400 Subject: [PATCH 61/91] Added the content for Teams and Ordered directives --- .../3_UsingOpenMP_teams.ipynb | 2 +- .../4_SynchronizationThreads.ipynb | 255 +++++++++++++++++- 2 files changed, 250 insertions(+), 7 deletions(-) diff --git a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb index a1f3cf7..cddfb88 100644 --- a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb +++ b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -836,7 +836,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb index dc8c947..b699ce4 100644 --- a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb @@ -5,7 +5,7 @@ "id": "274986cf-eb9d-43fb-9e5e-747375967074", "metadata": {}, "source": [ - "# Synchronization of threads using barrier and order directive" + "# Synchronization of Threads Using Barrier and Ordered Directive" ] }, { @@ -13,15 +13,258 @@ "id": "47ec2fe5-66c0-40e3-aeb2-128ddef90823", "metadata": {}, "source": [ - "OpenMP synchronization for barrier and order directive. " + "## Introduction to Synchronization in Parallel Programming with OpenMP\n", + "In parallel programming, synchronization is a fundamental concept that ensures that multiple threads or processes execute concurrently in a controlled manner. Synchronization mechanisms are crucial for maintaining the correctness and efficiency of parallel programs, particularly when multiple threads interact or share resources.\n", + "\n", + "OpenMP, a widely used directive-based parallel programming model, provides various synchronization constructs that help manage the complexities of concurrent execution. Among these, the barrier and ordered directives play pivotal roles in controlling the flow and order of execution across threads. Understanding these directives is essential for developing robust and efficient parallel applications.\n", + "\n", + " Barrier Directive: This directive is used to align threads at a synchronization point before any of them can proceed further. It ensures that all threads in a team reach a certain point in the execution before moving on. This is particularly useful when subsequent operations depend on the completion of certain tasks by all threads.\n", + "\n", + " ordered Directive: This directive controls the sequence of execution within loop iterations, making it possible to enforce a specific order when needed. It is essential in situations where the order of operations affects the outcome, such as in numerical simulations or cumulative operations.\n", + "\n", + "The correct use of these directives not only enhances the performance of parallel programs but also prevents common issues such as race conditions, deadlocks, and inconsistent outputs. In the following sections, we will explore each of these synchronization mechanisms in detail, providing usage examples and best practices to integrate them effectively into your OpenMP programs." ] + }, + { + "cell_type": "markdown", + "id": "6fb8c339-d224-4e79-b07e-2b29979c3aa4", + "metadata": {}, + "source": [ + "## Barrier Directive\n", + "\n", + "The Barrier Directive is an essential synchronization mechanism in OpenMP, designed to ensure that all threads within a parallel region reach a certain point in the code before any thread can proceed. This collective synchronization is crucial in scenarios where different threads must complete their assigned tasks before the next phase of computation begins.\n", + "\n", + "### Purpose of the Barrier Directive\n", + "\n", + "The primary purpose of the barrier directive is to synchronize threads, which helps to:\n", + "- Ensure that all preprocessing or initialization tasks are completed by all threads before moving on to the main computation.\n", + "- Prevent race conditions where threads might read or write shared data that has not yet been fully prepared by other threads.\n", + "- Manage the workflow in complex parallel tasks, making debugging and maintenance easier by defining clear synchronization points.\n", + "\n", + "### Usage\n", + "\n", + "The barrier directive is simple to use and can be added anywhere within a parallel region where synchronization is required. The syntax is as follows:\n", + "\n", + "```c\n", + "#pragma omp barrier\n", + "```\n", + "\n", + "This directive causes each thread to wait until all members of the team reach the barrier. Once the last thread arrives, all threads are released to continue execution beyond the barrier.\n", + "\n", + "### Example: Using the Barrier Directive\n", + "\n", + "Consider a scenario where multiple threads are tasked with initializing different sections of an array, and a subsequent computation requires the entire array to be initialized:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f07e684-a560-4118-aee9-6987be015aa8", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#define SIZE 100\n", + "int array[SIZE];\n", + "\n", + "void initialize_array() {\n", + " #pragma omp parallel num_threads(4)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " int chunk_size = SIZE / omp_get_num_threads();\n", + "\n", + " // Each thread initializes its portion of the array\n", + " for (int i = tid * chunk_size; i < (tid + 1) * chunk_size; i++) {\n", + " array[i] = compute_initial_value(i);\n", + " }\n", + "\n", + " // Wait for all threads to finish initializing\n", + " #pragma omp barrier\n", + "\n", + " // After the barrier, all parts of the array are initialized\n", + " if (tid == 0) { // Only the master thread executes this\n", + " for (int i = 0; i < SIZE; i++) {\n", + " process_array(i, array[i]);\n", + " }\n", + " }\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "60398ecb-7bc9-4d16-b795-8cc935f8b361", + "metadata": {}, + "source": [ + "In this example, the `#pragma omp barrier` ensures that no thread begins processing the array until all threads have completed their initialization tasks. This avoids any dependency issues and ensures that data is correctly prepared for subsequent operations.\n", + "\n", + "### Considerations\n", + "\n", + "While barriers are powerful, they should be used judiciously:\n", + "- **Performance**: Unnecessary barriers can degrade performance by forcing threads to wait, even if they could otherwise continue execution independently.\n", + "- **Deadlocks**: Incorrect use of barriers can lead to deadlocks, especially if not all threads reach the barrier.\n", + "\n", + "The barrier directive is a fundamental tool in OpenMP for coordinating the complex behaviors of multiple threads, ensuring that multi-threaded programs execute reliably and correctly." + ] + }, + { + "cell_type": "markdown", + "id": "2e53b4c4-828c-4639-afe9-e3ed9183f9ee", + "metadata": {}, + "source": [ + "## Ordered Directive\n", + "\n", + "In OpenMP, the ordered directive provides a method to manage the execution order of iterations within a parallel loop. This capability is critical in ensuring the orderly execution of code segments where the sequence of operations is important for correctness or performance.\n", + "\n", + "### Purpose of the Ordered Directive\n", + "\n", + "The ordered directive is particularly useful in scenarios where:\n", + "- The output sequence must match the input sequence, such as when writing to files or producing time-sensitive results.\n", + "- Operations within the loop have dependencies that require them to execute in a specific order.\n", + "\n", + "### Usage\n", + "\n", + "The ordered directive is typically used in conjunction with loop constructs and is specified using the `ordered` clause within a loop directive. The actual code block that needs to be ordered is marked with an `ordered` directive." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d6f4901-bcde-4961-9af5-1a12e25cd432", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#pragma omp for ordered\n", + "for (int i = 0; i < n; i++) {\n", + " // Pre-processing that can be done out of order\n", + " #pragma omp ordered\n", + " {\n", + " // Code here is executed in the order of loop iterations\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "8ed7a864-edc1-4389-9e45-7eaa047136bc", + "metadata": {}, + "source": [ + "This structure allows the bulk of the loop to execute in parallel, with only the critical section that needs ordering being controlled.\n", + "\n", + "### Compatibility with the doacross Clause\n", + "\n", + "The `ordered` directive can be effectively combined with the `doacross` loop schedule, which provides finer control over loop iteration dependencies. The `doacross` clause enables specifying dependencies across loop iterations, which can be crucial for loops where iteration \\( i \\) must complete certain operations before iteration \\( i+1 \\) can begin effectively:\n", + "\n", + "```c\n", + "#pragma omp for ordered(2) doacross\n", + "for (int i = 0; i < n; i++) {\n", + " #pragma omp ordered depend(sink: i-1)\n", + " {\n", + " process_step(i);\n", + " }\n", + " #pragma omp ordered depend(source)\n", + " {\n", + " continue_process(i);\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, each iteration of the loop depends on the completion of the previous iteration, controlled by the `ordered` and `doacross` clauses. This setup is ideal for scenarios requiring tightly coupled iterative operations.\n", + "### Example: Serial Output in Parallel Loop\n", + "\n", + "Consider a case where multiple threads perform calculations, but results must be output in the original order of the loop indices:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d01c44f-4eb5-4e44-95e6-d7db207b14b2", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "\n", + "void ordered_output() {\n", + " int n = 100;\n", + " #pragma omp parallel for ordered\n", + " for (int i = 0; i < n; i++) {\n", + " int result = complex_calculation(i);\n", + " #pragma omp ordered\n", + " {\n", + " printf(\"Result for %d: %d\\n\", i, result);\n", + " }\n", + " }\n", + "}\n", + "\n", + "int complex_calculation(int x) {\n", + " return x * x; // A placeholder for a more complex operation\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "6a88e2de-e3d4-470a-95f4-4567da54b95a", + "metadata": {}, + "source": [ + "In this example, the `complex_calculation` function can be executed in parallel, but the `printf` function inside the `ordered` block ensures that results are printed in the sequence corresponding to the increasing order of `i`.\n", + "\n", + "### Considerations\n", + "\n", + "- **Performance**: While the ordered directive is powerful for controlling execution sequence, it can significantly reduce parallelism, potentially leading to performance degradation. It should be used only when necessary.\n", + "- **Compatibility**: Ensure that the use of the ordered directive is compatible with the chosen loop scheduling strategy, as some combinations may lead to inefficient execution.\n", + "\n", + "Using the ordered directive effectively allows developers to balance the needs for parallel execution and sequential order, providing control over how and when certain parts of the code execute relative to others." + ] + }, + { + "cell_type": "markdown", + "id": "687f66a9-5ff2-4bfa-b19d-e30bf30278ae", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this chapter, we explored two crucial synchronization mechanisms in OpenMP: the barrier and ordered directives. These directives are fundamental tools for managing the complexities and challenges of parallel programming, ensuring that multi-threaded operations execute in a controlled and predictable manner.\n", + "\n", + "- **Barrier Directive**: We discussed how the barrier directive is used to synchronize all threads at a specific point within a parallel region. This synchronization ensures that all threads complete their tasks up to the barrier before any thread can proceed, which is essential for tasks that require all preceding operations to be completed before continuing. The barrier directive is invaluable for maintaining data integrity and order in multi-threaded environments.\n", + "\n", + "- **Ordered Directive**: We examined the ordered directive, which controls the sequence of iteration execution within loop constructs. This directive is particularly useful when the order of operations affects the outcome, such as outputting results in a sequential order or performing cumulative calculations that depend on the sequence of data processing. By allowing parts of the loop to execute in parallel while controlling the order of critical sections, the ordered directive balances efficiency with the necessity for order.\n", + "\n", + "### Key Takeaways:\n", + "\n", + "1. **Correct Use Enhances Performance**: While both directives impose some synchronization overhead, their correct use can lead to significant improvements in program correctness and stability. It's essential to use these synchronization tools judiciously to enhance performance without compromising the benefits of parallel execution.\n", + "\n", + "2. **Prevent Common Issues**: These directives help prevent common parallel programming issues such as race conditions, deadlocks, and incorrect data handling. Understanding when and how to use these tools is critical for developing robust parallel applications.\n", + "\n", + "3. **Application Scenarios**: Whether synchronizing data access with barriers or ensuring ordered operations with the ordered directive, these tools are applicable in a wide range of scenarios in scientific computing, data processing, and real-time system operations.\n", + "\n", + "This chapter has provided a foundational understanding of synchronization in OpenMP, equipping you with the knowledge to effectively apply these mechanisms in your parallel programming projects. As you continue to explore OpenMP, remember that the thoughtful application of synchronization constructs is key to unlocking the full potential of parallel computing resources." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f86ad17-a4b0-411d-9921-c05186c93225", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + "display_name": "Native", + "language": "native", + "name": "native" }, "language_info": { "codemirror_mode": { @@ -33,7 +276,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.8.10" } }, "nbformat": 4, From d9dbde87f58ab1b5c3a3fc0eff4e18a23f95be54 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Thu, 2 May 2024 11:46:10 -0400 Subject: [PATCH 62/91] Added different versions from 2 other LLMs --- .../4_SynchronizationThreads.ipynb | 9 +- .../4_SynchronizationThreads_Claude.ipynb | 574 ++++++++++++++++++ .../4_SynchronizationThreads_Gemini.ipynb | 226 +++++++ src/_toc.yml | 2 + 4 files changed, 808 insertions(+), 3 deletions(-) create mode 100644 src/MultiCoreMultiCPU/4_SynchronizationThreads_Claude.ipynb create mode 100644 src/MultiCoreMultiCPU/4_SynchronizationThreads_Gemini.ipynb diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb index b699ce4..353dc66 100644 --- a/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads.ipynb @@ -11,16 +11,19 @@ { "cell_type": "markdown", "id": "47ec2fe5-66c0-40e3-aeb2-128ddef90823", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, "source": [ "## Introduction to Synchronization in Parallel Programming with OpenMP\n", "In parallel programming, synchronization is a fundamental concept that ensures that multiple threads or processes execute concurrently in a controlled manner. Synchronization mechanisms are crucial for maintaining the correctness and efficiency of parallel programs, particularly when multiple threads interact or share resources.\n", "\n", "OpenMP, a widely used directive-based parallel programming model, provides various synchronization constructs that help manage the complexities of concurrent execution. Among these, the barrier and ordered directives play pivotal roles in controlling the flow and order of execution across threads. Understanding these directives is essential for developing robust and efficient parallel applications.\n", "\n", - " Barrier Directive: This directive is used to align threads at a synchronization point before any of them can proceed further. It ensures that all threads in a team reach a certain point in the execution before moving on. This is particularly useful when subsequent operations depend on the completion of certain tasks by all threads.\n", + "- Barrier Directive: This directive is used to align threads at a synchronization point before any of them can proceed further. It ensures that all threads in a team reach a certain point in the execution before moving on. This is particularly useful when subsequent operations depend on the completion of certain tasks by all threads.\n", "\n", - " ordered Directive: This directive controls the sequence of execution within loop iterations, making it possible to enforce a specific order when needed. It is essential in situations where the order of operations affects the outcome, such as in numerical simulations or cumulative operations.\n", + "- Ordered Directive: This directive controls the sequence of execution within loop iterations, making it possible to enforce a specific order when needed. It is essential in situations where the order of operations affects the outcome, such as in numerical simulations or cumulative operations.\n", "\n", "The correct use of these directives not only enhances the performance of parallel programs but also prevents common issues such as race conditions, deadlocks, and inconsistent outputs. In the following sections, we will explore each of these synchronization mechanisms in detail, providing usage examples and best practices to integrate them effectively into your OpenMP programs." ] diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads_Claude.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads_Claude.ipynb new file mode 100644 index 0000000..a5b6128 --- /dev/null +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads_Claude.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "274986cf-eb9d-43fb-9e5e-747375967074", + "metadata": {}, + "source": [ + "# Synchronization of Threads Using Barrier and Ordered Directive" + ] + }, + { + "cell_type": "markdown", + "id": "47ec2fe5-66c0-40e3-aeb2-128ddef90823", + "metadata": { + "tags": [] + }, + "source": [ + "## Introduction\n", + "\n", + "Parallel programming involves dividing a task into smaller subtasks and executing them concurrently on multiple processing units, such as CPU cores or GPU threads. While parallelism can significantly improve performance, it also introduces challenges related to synchronization and coordination among the parallel threads or tasks.\n", + "\n", + "In OpenMP, the `barrier` and `ordered` directives provide mechanisms for synchronizing the execution of parallel threads. These directives ensure that certain operations are performed in a specific order, preventing potential race conditions and ensuring the correctness of parallel computations.\n", + "\n", + "### Importance of Thread Synchronization\n", + "\n", + "In parallel programming, threads often need to coordinate their activities and share data or resources. Without proper synchronization, race conditions can occur, leading to incorrect results or program crashes. Race conditions arise when two or more threads access a shared resource concurrently, and the final result depends on the relative timing of their execution.\n", + "\n", + "Thread synchronization is essential for ensuring the following:\n", + "\n", + "1. **Correct Execution Order**: In some cases, it is necessary to enforce a specific execution order among threads to ensure the correct computation of results or to avoid data races.\n", + "2. **Coordinated Access to Shared Resources**: When multiple threads access shared data or resources, synchronization is needed to prevent concurrent access and ensure data consistency.\n", + "3. **Barrier Points**: Threads may need to reach a common synchronization point before proceeding to the next phase of computation or before accessing shared data.\n", + "\n", + "By using synchronization mechanisms like barriers and ordered directives, developers can control the execution flow of parallel threads, ensuring data integrity and program correctness.\n", + "\n", + "### Overview of the Barrier and Ordered Directives\n", + "\n", + "The `barrier` and `ordered` directives in OpenMP provide different mechanisms for synchronizing threads:\n", + "\n", + "1. **Barrier Directive**: The `barrier` directive introduces a synchronization point where all threads in a parallel region must wait until all threads have reached the barrier. This ensures that all threads have completed their work before proceeding to the next phase of computation.\n", + "\n", + "2. **Ordered Directive**: The `ordered` directive is used in conjunction with loop constructs to enforce a specific execution order for loop iterations. It guarantees that loop iterations are executed in the same order as they would be executed in a sequential loop, even when executed in parallel.\n", + "\n", + "In the following sections, we will explore the details of these directives, their usage, best practices, and examples to illustrate their application in parallel programming with OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "0299cba9-9b6b-42dd-a8c6-2d88f6c69794", + "metadata": {}, + "source": [ + "## Barrier Directive\n", + "\n", + "The barrier directive in OpenMP is a powerful synchronization mechanism that ensures all threads in a parallel region have completed their work before proceeding to the next phase of computation.\n", + "\n", + "### Purpose and Usage\n", + "\n", + "The primary purpose of the barrier directive is to introduce a synchronization point where all threads must wait until every thread in the parallel region has reached the barrier. This synchronization is essential in scenarios where threads need to exchange data, access shared resources, or coordinate their activities before moving to the next stage of computation.\n", + "\n", + "Barriers are commonly used in parallel programming to:\n", + "\n", + "1. **Ensure Correct Ordering**: By enforcing a barrier, threads can complete their work before proceeding to the next phase, avoiding race conditions and ensuring the correctness of the results.\n", + "2. **Coordinate Data Sharing**: Barriers can be used to ensure that all threads have completed their updates to shared data before other threads access it, preventing data races and maintaining data consistency.\n", + "3. **Separate Computation Phases**: In algorithms with multiple phases, barriers can separate the phases, ensuring that all threads have completed the current phase before moving to the next one.\n", + "\n", + "### Syntax and Examples\n", + "\n", + "The syntax for the barrier directive in C/C++ is:\n", + "\n", + "```c\n", + "#pragma omp barrier\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp barrier\n", + "```\n", + "\n", + "Here's a simple example in C++ that demonstrates the use of the barrier directive:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " int num_threads = 4;\n", + " omp_set_num_threads(num_threads);\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " int thread_id = omp_get_thread_num();\n", + "\n", + " // Work before the barrier\n", + " std::cout << \"Thread \" << thread_id << \" working...\" << std::endl;\n", + "\n", + " #pragma omp barrier\n", + "\n", + " // Work after the barrier\n", + " std::cout << \"Thread \" << thread_id << \" continuing...\" << std::endl;\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, each thread performs some work and prints a message before reaching the barrier. After all threads have reached the barrier, they proceed to execute the code after the barrier.\n", + "\n", + "### Barrier Regions\n", + "\n", + "The barrier directive can be used within a parallel region, which is a block of code enclosed by the `parallel` directive or other parallel constructs like `for` or `sections`. When a thread encounters a barrier within a parallel region, it must wait at that point until all other threads in the same parallel region have also reached the barrier.\n", + "\n", + "It's important to note that barriers only synchronize threads within the same parallel region. Threads in different parallel regions or nested parallel regions are not affected by barriers in other regions.\n", + "\n", + "### Synchronization Points\n", + "\n", + "The barrier directive introduces a synchronization point where all threads must wait until every thread has reached the barrier. This synchronization ensures that:\n", + "\n", + "1. All threads have completed their work before the barrier.\n", + "2. No thread proceeds beyond the barrier until all threads have reached the barrier.\n", + "3. After all threads have reached the barrier, they can continue executing the code following the barrier.\n", + "\n", + "Synchronization points are crucial for maintaining data consistency and avoiding race conditions when multiple threads access shared resources or perform operations that depend on the results produced by other threads." + ] + }, + { + "cell_type": "markdown", + "id": "9801c39e-5c4a-4856-9929-23ef420ce55a", + "metadata": {}, + "source": [ + "## 3. Ordered Directive\n", + "\n", + "The ordered directive in OpenMP is a synchronization construct that enforces the execution order of loop iterations in a parallel region. It ensures that the iterations are executed in the same order as they would be in a sequential loop, even when executed in parallel. OpenMP provides two forms of the ordered directive: the stand-alone ordered construct and the block-associated ordered construct.\n", + "\n", + "### 3.1. Purpose and Usage\n", + "\n", + "The primary purpose of the ordered directive is to maintain the correct ordering of loop iterations when executing them in parallel. This is crucial in situations where the order of execution affects the correctness of the results or when there are cross-iteration dependencies.\n", + "\n", + "The ordered directive is commonly used in the following scenarios:\n", + "\n", + "1. **Preserving Sequential Semantics**: When parallelizing loops that have cross-iteration dependencies or side effects that depend on the order of execution, the ordered directive ensures that the loop iterations are executed in the correct order, preserving the semantics of the sequential version.\n", + "\n", + "2. **Ordered Output**: When the output of loop iterations needs to be printed or written in a specific order, the ordered directive can ensure that the output is generated in the correct sequence.\n", + "\n", + "3. **Ordered Access to Resources**: If loop iterations need to access shared resources (e.g., files, network connections) in a specific order, the ordered directive can enforce the desired access order.\n", + "\n", + "### 3.2. Syntax and Examples\n", + "\n", + "The syntax for the ordered directive in C/C++ is:\n", + "\n", + "```c\n", + "#pragma omp ordered\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp ordered\n", + "```\n", + "\n", + "Here's an example in C++ that demonstrates the use of the ordered directive within a parallel loop:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 10;\n", + "\n", + " #pragma omp parallel for ordered\n", + " for (int i = 0; i < N; ++i) {\n", + " #pragma omp ordered\n", + " {\n", + " std::cout << \"Iteration \" << i << \" executed.\" << std::endl;\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the loop iterations are executed in parallel, but the output from each iteration is printed in the correct order (0, 1, 2, ..., 9) due to the ordered directive.\n", + "\n", + "### 3.3. Enforcing Execution Order\n", + "\n", + "The ordered directive ensures that the execution order of loop iterations in a parallel region follows the same order as the sequential loop execution. This is achieved by introducing an implicit barrier at the beginning of each ordered region, where threads must wait for their turn to execute the ordered region.\n", + "\n", + "When a thread encounters an ordered region, it waits until all preceding iterations have completed their ordered regions before executing its own ordered region. This guarantees that the ordered regions are executed in the correct sequential order, even though the loop iterations themselves may be executed in parallel.\n", + "\n", + "### 3.4. Ordered Regions\n", + "\n", + "An ordered region is a block of code enclosed by the ordered directive. Within an ordered region, the code is executed in the correct sequential order by the threads executing the loop iterations.\n", + "\n", + "The ordered directive can be placed inside a parallel loop construct (e.g., `parallel for`) or within a worksharing loop construct (e.g., `for`, `do`). When a thread encounters an ordered region, it waits at the implicit barrier until it is its turn to execute the ordered region, ensuring the correct ordering of loop iterations.\n", + "\n", + "### 3.5. Stand-alone Ordered Construct\n", + "\n", + "The stand-alone ordered construct is a form of the ordered directive that specifies execution must not violate cross-iteration dependences as specified by the `doacross` clauses.\n", + "\n", + "#### 3.5.1. Semantics\n", + "\n", + "When a thread executing an iteration encounters a stand-alone ordered construct with one or more `doacross` clauses for which the `sink` dependence-type is specified, the thread waits until its dependences on all valid iterations specified by the `doacross` clauses are satisfied before continuing execution. A specific dependence is satisfied when a thread executing the corresponding iteration encounters an ordered construct with a `doacross` clause for which the `source` dependence-type is specified.\n", + "\n", + "#### 3.5.2. Execution Model Events and Tool Callbacks\n", + "\n", + "The OpenMP specification defines two execution model events and associated tool callbacks for the stand-alone ordered construct:\n", + "\n", + "1. **doacross-sink Event**: Occurs in the task that encounters an ordered construct for each `doacross` clause with the `sink` dependence-type after the dependence is fulfilled.\n", + "\n", + "2. **doacross-source Event**: Occurs in the task that encounters an ordered construct with a `doacross` clause for which the `source` dependence-type is specified before signaling that the dependence has been fulfilled.\n", + "\n", + "#### 3.5.3. Restrictions\n", + "\n", + "The stand-alone ordered construct has the following restrictions:\n", + "\n", + "- At most one `doacross` clause may appear on the construct with `source` as the dependence-type.\n", + "- All `doacross` clauses that appear on the construct must specify the same dependence-type.\n", + "- The construct must not be an orphaned construct.\n", + "\n", + "### 3.6. Block-associated Ordered Construct\n", + "\n", + "The block-associated ordered construct is a form of the ordered directive that is associated with a block of code within a loop construct.\n", + "\n", + "#### 3.6.1. Semantics\n", + "\n", + "If no clauses are specified, the effect is as if the `threads` parallelization-level clause was specified. If the `threads` clause is specified, the threads in the team executing the worksharing-loop region execute ordered regions sequentially in the order of the loop iterations.\n", + "\n", + "If the `simd` parallelization-level clause is specified, the ordered regions encountered by any thread will execute one at a time in the order of the loop iterations. With either parallelization-level, execution of code outside the region for different iterations can run in parallel, but execution within the same iteration must observe any constraints imposed by the base-language semantics.\n", + "\n", + "When the thread executing the first iteration of the loop encounters a block-associated ordered construct, it can enter the ordered region without waiting. For subsequent iterations, a thread waits at the beginning of the ordered region until execution of all ordered regions that belong to all previous iterations has completed.\n", + "\n", + "#### 3.6.2. parallelization-level Clauses\n", + "\n", + "The `parallelization-level` clause group consists of the `simd` and `threads` clauses, which indicate the level of parallelization associated with the ordered construct.\n", + "\n", + "#### 3.6.3. Restrictions\n", + "\n", + "The block-associated ordered construct has the following restrictions:\n", + "\n", + "- The construct is simdizable only if the `simd` parallelization-level is specified.\n", + "- If the `simd` parallelization-level is specified, the binding region must be a `simd` region or a combined/composite construct with `simd` as a leaf construct.\n", + "- If the `threads` parallelization-level is specified, the binding region must be a worksharing-loop region or a combined/composite construct with worksharing-loop as a leaf construct.\n", + "- If the `threads` parallelization-level is specified and the binding region corresponds to a combined/composite construct, the `simd` construct must not be a leaf construct unless the `simd` parallelization-level is also specified.\n", + "- During the logical iteration of a loop-associated construct, a thread must not execute more than one block-associated ordered region that binds to the corresponding region of the loop-associated construct.\n", + "- An `ordered` clause with a parameter value equal to one must appear on the construct that corresponds to the binding region.\n", + "\n", + "### 3.7. Interaction with Loop Constructs and Clauses\n", + "\n", + "The ordered directive is closely related to and often used in conjunction with loop constructs and clauses in OpenMP. Here are some key interactions:\n", + "\n", + "- The ordered directive can be used within parallel loop constructs (e.g., `parallel for`) or worksharing loop constructs (e.g., `for`, `do`).\n", + "- The `ordered` clause must be present on the construct that corresponds to the binding region of an ordered region.\n", + "- The construct that corresponds to the binding region of an ordered region must not specify a `reduction` clause with the `inscan` modifier.\n", + "\n", + "### 3.8. Best Practices\n", + "\n", + "When using the ordered directive, consider the following best practices:\n", + "\n", + "- Use the ordered directive judiciously, as it can introduce overhead and potentially limit parallelism.\n", + "- Carefully analyze cross-iteration dependencies and side effects to determine if the ordered directive is necessary.\n", + "- Consider alternative approaches, such as privatization or reduction, if possible, to avoid the need for ordered execution.\n", + "- If using the stand-alone ordered construct, minimize the number of `doacross` clauses and ensure they are necessary for correctness.\n", + "- Profile and optimize the performance of ordered regions, especially in performance-critical sections of the code.\n", + "- Ensure proper synchronization and avoid race conditions when accessing shared data within ordered regions.\n", + "\n", + "By following these best practices, you can effectively use the ordered directive to maintain the correct execution order while minimizing potential performance overhead and" + ] + }, + { + "cell_type": "markdown", + "id": "3668c1f6-a369-4eda-b841-585c85ae2d3c", + "metadata": {}, + "source": [ + "## 4. Combining Barrier and Ordered Directives\n", + "\n", + "While the `barrier` and `ordered` directives in OpenMP serve different purposes, there are scenarios where combining them can be beneficial or even necessary. This section explores the use cases for combining these directives and provides examples and considerations.\n", + "\n", + "### 4.1. Use Cases for Combining Directives\n", + "\n", + "Combining the `barrier` and `ordered` directives can be useful in the following situations:\n", + "\n", + "1. **Enforcing Synchronization and Order**: In some algorithms or computations, it may be necessary to ensure that all threads have reached a specific point (barrier) and that subsequent operations are executed in a specific order (ordered). This combination can help maintain correctness and avoid race conditions or data inconsistencies.\n", + "\n", + "2. **Separating Computation Phases**: When an algorithm or computation consists of multiple phases, barriers can separate the phases, ensuring that all threads have completed the current phase before moving to the next one. Within each phase, the ordered directive can be used to enforce the correct execution order of loop iterations or operations.\n", + "\n", + "3. **Coordinated Access to Shared Resources**: If multiple threads need to access shared resources (e.g., files, network connections) in a specific order, the ordered directive can enforce the desired access order. Barriers can be used to ensure that all threads have completed their tasks before proceeding to the next phase or accessing the shared resources.\n", + "\n", + "4. **Parallel I/O**: In parallel I/O operations, where multiple threads are writing to a shared file or output stream, the ordered directive can ensure that the output is generated in the correct sequence. Barriers can be used to synchronize the threads before and after the I/O operations to ensure consistency and avoid race conditions.\n", + "\n", + "### 4.2. Examples and Code Snippets\n", + "\n", + "Here's an example that combines the `barrier` and `ordered` directives in a parallel computation:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 10;\n", + " int data[N];\n", + "\n", + " // Initialize data\n", + " for (int i = 0; i < N; i++) {\n", + " data[i] = i;\n", + " }\n", + "\n", + " #pragma omp parallel for ordered\n", + " for (int i = 0; i < N; i++) {\n", + " // Phase 1: Perform some computation\n", + " data[i] *= 2;\n", + "\n", + " #pragma omp ordered\n", + " {\n", + " std::cout << \"Iteration \" << i << \" completed phase 1.\" << std::endl;\n", + " }\n", + "\n", + " #pragma omp barrier\n", + "\n", + " // Phase 2: Perform another computation\n", + " data[i] += 1;\n", + "\n", + " #pragma omp ordered\n", + " {\n", + " std::cout << \"Iteration \" << i << \" completed phase 2.\" << std::endl;\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the parallel loop is executed with the `ordered` directive, ensuring that the iterations are executed in the correct order. Within each iteration, there are two phases of computation separated by a barrier. The ordered directive is used to print a message indicating the completion of each phase for each iteration, ensuring that the output is generated in the correct sequence.\n", + "\n", + "### 4.3. Considerations and Potential Issues\n", + "\n", + "When combining the `barrier` and `ordered` directives, consider the following:\n", + "\n", + "1. **Overhead**: Both directives introduce synchronization overhead, which can potentially impact performance. Use them judiciously and only when necessary for correctness or required semantics.\n", + "\n", + "2. **Deadlock Potential**: Improper use of barriers and ordered directives can lead to deadlock situations, where threads are waiting for conditions that can never be satisfied. Carefully analyze the code and ensure that all threads can eventually satisfy the synchronization requirements.\n", + "\n", + "3. **Nesting and Nested Parallelism**: Be cautious when nesting parallel regions or combining these directives with nested parallelism. Ensure that the synchronization requirements are correctly enforced across all levels of parallelism.\n", + "\n", + "4. **Data Consistency and Race Conditions**: While these directives can help maintain correct execution order, they do not inherently protect against data races or ensure data consistency. Proper use of shared and private data, as well as synchronization mechanisms like critical sections or atomic operations, may still be necessary.\n", + "\n", + "By understanding the use cases, considering potential issues, and following best practices, you can effectively combine the `barrier` and `ordered` directives in your OpenMP programs to enforce synchronization requirements and maintain correct execution order." + ] + }, + { + "cell_type": "markdown", + "id": "b908f96d-4e6c-4d1f-a920-139b67bbf492", + "metadata": {}, + "source": [ + "## 5. Implicit Barriers\n", + "\n", + "In addition to the explicit `barrier` directive, OpenMP also defines implicit barriers that occur at the end of various regions, such as worksharing regions and parallel regions. This section discusses implicit barrier regions, their execution model events, and associated tool callbacks.\n", + "\n", + "### 5.1. Implicit Barrier Regions\n", + "\n", + "Implicit barriers are task scheduling points that occur at the end of certain OpenMP constructs, as defined in the description of those constructs. These implicit barriers ensure that all threads have completed their work within the corresponding region before proceeding further.\n", + "\n", + "Implicit barriers occur in the following situations:\n", + "\n", + "1. **At the end of a worksharing construct**: An implicit barrier is introduced to ensure that all threads have completed the worksharing region before proceeding to the next step.\n", + "\n", + "2. **At the end of a parallel region**: When a parallel region ends, an implicit barrier synchronizes all threads before they can continue executing the code following the parallel region.\n", + "\n", + "3. **Implementation-added barriers**: In some cases, OpenMP implementations may add extra implicit barriers for internal purposes or optimizations.\n", + "\n", + "4. **At the end of a teams region**: After a teams region, an implicit barrier ensures that all teams have completed their work before the program can proceed.\n", + "\n", + "### 5.2. Execution Model Events and Tool Callbacks\n", + "\n", + "The OpenMP specification defines execution model events and associated tool callbacks for implicit barriers, similar to those for explicit barriers. These events and callbacks enable tools and libraries to monitor and analyze the behavior of implicit barriers.\n", + "\n", + "Execution Model Events:\n", + "\n", + "1. **implicit-barrier-begin**: Occurs in each implicit task at the beginning of an implicit barrier region.\n", + "2. **implicit-barrier-wait-begin**: Occurs when a task begins an interval of active or passive waiting in an implicit barrier region.\n", + "3. **implicit-barrier-wait-end**: Occurs when a task ends an interval of active or passive waiting and resumes execution in an implicit barrier region.\n", + "4. **implicit-barrier-end**: Occurs in each implicit task after the barrier synchronization on exit from an implicit barrier region.\n", + "5. **Cancellation Event**: Occurs if cancellation is activated at an implicit cancellation point in an implicit barrier region.\n", + "\n", + "Tool Callbacks:\n", + "\n", + "1. **ompt_callback_sync_region**: Dispatched for each implicit barrier begin and end event, as well as for implicit barrier wait-begin and wait-end events. These callbacks execute in the context of the encountering task and have the type signature `ompt_callback_sync_region_t`.\n", + "\n", + "2. **ompt_callback_cancel**: Dispatched with the `ompt_cancel_detected` flag for each occurrence of a cancellation event in that thread. This callback occurs in the context of the encountering task and has the type signature `ompt_callback_cancel_t`.\n", + "\n", + "The specific kind of implicit barrier is identified by the `kind` argument passed to the `ompt_callback_sync_region` callback. For example, the kind argument is `ompt_sync_region_barrier_implicit_workshare` for the implicit barrier at the end of a worksharing construct, and `ompt_sync_region_barrier_implicit_parallel` for the implicit barrier at the end of a parallel region.\n", + "\n", + "Understanding implicit barriers and their associated events and callbacks can be useful for debugging, profiling, and analyzing the behavior of OpenMP programs, particularly when dealing with synchronization and performance issues." + ] + }, + { + "cell_type": "markdown", + "id": "d1895a7e-c3f4-44a7-847c-fd8c52d60287", + "metadata": {}, + "source": [ + "## 6. Advanced Topics\n", + "\n", + "While the basic usage of the `barrier` and `ordered` directives provides a solid foundation for synchronizing threads in OpenMP programs, there are several advanced topics that can further enhance the flexibility and efficiency of your applications. This section explores some of these advanced topics.\n", + "\n", + "### 6.1. Nested Barrier and Ordered Directives\n", + "\n", + "OpenMP supports nested parallelism, where parallel regions can be defined within other parallel regions. In such scenarios, the `barrier` and `ordered` directives can also be nested, allowing for more complex synchronization patterns.\n", + "\n", + "#### 6.1.1. Nested Barriers\n", + "\n", + "Nested barriers can be used to synchronize threads within a specific level of nested parallelism. For example, you can use a barrier to synchronize threads within an inner parallel region, without affecting the threads in the outer parallel region.\n", + "\n", + "```cpp\n", + "#pragma omp parallel\n", + "{\n", + " // Outer parallel region\n", + "\n", + " #pragma omp barrier\n", + " // Barrier for threads in the outer region\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " // Inner parallel region\n", + "\n", + " #pragma omp barrier\n", + " // Barrier for threads in the inner region\n", + " }\n", + "}\n", + "```\n", + "\n", + "Proper use of nested barriers can help manage complex synchronization scenarios and ensure that threads are synchronized at the appropriate levels of parallelism.\n", + "\n", + "#### 6.1.2. Nested Ordered Directives\n", + "\n", + "Similar to nested barriers, the `ordered` directive can also be nested within parallel regions. This can be useful when enforcing the correct execution order of loop iterations at different levels of parallelism.\n", + "\n", + "```cpp\n", + "#pragma omp parallel for ordered\n", + "for (int i = 0; i < N; ++i) {\n", + " #pragma omp ordered\n", + " {\n", + " // Code for outer ordered region\n", + " #pragma omp parallel for ordered\n", + " for (int j = 0; j < M; ++j) {\n", + " #pragma omp ordered\n", + " {\n", + " // Code for inner ordered region\n", + " }\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the outer `ordered` region enforces the correct execution order of iterations of the outer loop, while the inner `ordered` region enforces the correct order for the inner loop iterations within each outer iteration.\n", + "\n", + "### 6.2. Interoperability with Other Synchronization Mechanisms\n", + "\n", + "OpenMP supports interoperability with other synchronization mechanisms, such as POSIX threads (Pthreads) or system-specific synchronization primitives. This interoperability allows you to combine the benefits of OpenMP's high-level synchronization constructs with lower-level synchronization mechanisms when needed.\n", + "\n", + "For example, you can use OpenMP barriers in combination with Pthreads mutexes or condition variables to implement complex synchronization protocols or to ensure correct interaction between OpenMP threads and non-OpenMP threads.\n", + "\n", + "### 6.3. Synchronization in the Context of Tasking\n", + "\n", + "OpenMP's tasking model introduces additional synchronization challenges and opportunities. While the `barrier` and `ordered` directives operate at the level of parallel regions and loop iterations, tasks may require different synchronization mechanisms.\n", + "\n", + "OpenMP provides constructs like `taskgroup` and `taskwait` to synchronize tasks, as well as task dependencies and data dependencies to enforce ordering and synchronization between tasks. These task-level synchronization mechanisms can be combined with the `barrier` and `ordered` directives to achieve complex synchronization patterns in task-parallel applications.\n", + "\n", + "### 6.4. Debugging and Profiling Synchronization Issues\n", + "\n", + "Debugging and profiling synchronization issues in parallel programs can be challenging due to the non-deterministic nature of thread execution and potential race conditions. OpenMP provides tool callbacks and execution model events that can be leveraged by debugging and profiling tools to analyze and understand the behavior of synchronization constructs like barriers and ordered directives.\n", + "\n", + "By using OpenMP-aware debugging and profiling tools, you can identify potential issues such as deadlocks, race conditions, or performance bottlenecks related to synchronization. These tools can provide valuable insights into the execution order of threads, the duration of synchronization operations, and other relevant metrics.\n", + "\n", + "Effective use of debugging and profiling tools can help you optimize the performance of your OpenMP applications and ensure the correct synchronization of threads, especially in complex parallel scenarios." + ] + }, + { + "cell_type": "markdown", + "id": "85c07ba5-0bec-4366-84f0-d0017920bc48", + "metadata": {}, + "source": [ + "## 7. Performance Considerations\n", + "\n", + "While the `barrier` and `ordered` directives are essential for ensuring the correct execution of parallel programs, they can also introduce overhead and potential performance bottlenecks. In this section, we explore various performance considerations related to the use of these synchronization constructs.\n", + "\n", + "### 7.1. Overhead and Scalability\n", + "\n", + "Synchronization operations, such as barriers and ordered execution, can add significant overhead to parallel programs. This overhead arises from the need for threads to coordinate and wait for each other, potentially leading to idle time and reduced efficiency.\n", + "\n", + "The performance impact of synchronization overhead can become more pronounced as the number of threads or the size of the problem increases. It is important to carefully analyze the scalability of your parallel program and assess the trade-off between synchronization overhead and the benefits of parallelism.\n", + "\n", + "### 7.2. Load Balancing and Synchronization Granularity\n", + "\n", + "Effective load balancing is crucial for achieving optimal performance in parallel programs. However, synchronization constructs like barriers and ordered directives can introduce load imbalances if not used judiciously.\n", + "\n", + "For example, if threads reach a barrier at different times, some threads may have to wait for others, leading to idle time and reduced efficiency. Similarly, if the granularity of ordered execution is too fine-grained, the overhead of enforcing the correct order can outweigh the benefits of parallelism.\n", + "\n", + "To mitigate these issues, it is essential to strike a balance between the granularity of synchronization and the potential for load imbalance. Techniques like dynamic load balancing, work stealing, or coarser-grained synchronization can help reduce the impact of load imbalances and improve overall performance.\n", + "\n", + "### 7.3. Performance Tuning and Optimization\n", + "\n", + "Optimizing the performance of parallel programs that use synchronization constructs often requires a combination of analysis, profiling, and careful tuning. Here are some strategies that can help improve performance:\n", + "\n", + "1. **Profiling and Identifying Bottlenecks**: Use profiling tools and OpenMP-aware debugging tools to identify performance bottlenecks related to synchronization. Look for hotspots where threads spend significant time waiting at barriers or ordered regions.\n", + "\n", + "2. **Reducing Unnecessary Synchronization**: Carefully analyze your code and remove any unnecessary synchronization operations. Eliminating unnecessary barriers or ordered regions can significantly improve performance.\n", + "\n", + "3. **Leveraging Hardware Characteristics**: Understand the characteristics of your hardware, such as the number of cores, cache sizes, and memory bandwidth. Adjust the granularity of synchronization and the number of threads to maximize hardware utilization and minimize contention for shared resources.\n", + "\n", + "4. **Overlapping Computation and Synchronization**: In some cases, it may be possible to overlap computation with synchronization operations. For example, instead of waiting at a barrier, threads can perform other computations or prefetch data, reducing idle time.\n", + "\n", + "5. **Exploring Alternative Synchronization Mechanisms**: Depending on the specific requirements of your program, alternative synchronization mechanisms like locks, semaphores, or atomic operations may be more efficient than barriers or ordered directives in certain situations.\n", + "\n", + "6. **Optimizing Data Locality and Memory Access Patterns**: Optimizing data locality and memory access patterns can also impact the performance of synchronization constructs. Reducing false sharing, improving cache utilization, and minimizing remote memory accesses can lead to better overall performance.\n", + "\n", + "By carefully considering these performance factors and employing appropriate optimization strategies, you can ensure that your parallel programs leverage the full potential of modern hardware while minimizing the overhead introduced by synchronization constructs like barriers and ordered directives." + ] + }, + { + "cell_type": "markdown", + "id": "e1580fb1-84eb-4f4c-986b-9d223bce7466", + "metadata": {}, + "source": [ + "## 9. Summary and Conclusion\n", + "\n", + "The `barrier` and `ordered` directives in OpenMP are essential synchronization constructs that enable the correct and efficient coordination of threads in parallel programs. They provide mechanisms to enforce synchronization points, ensure the correct execution order, and maintain data consistency in shared-memory parallel programming.\n", + "\n", + "The `barrier` directive introduces an explicit synchronization point where all threads in a team must wait until every thread has reached the barrier. This construct is crucial for separating parallel regions, coordinating access to shared resources, and ensuring that all threads have completed their work before proceeding to the next phase of computation.\n", + "\n", + "The `ordered` directive, on the other hand, enforces the execution order of loop iterations in a parallel region. It guarantees that the iterations are executed in the same order as they would be in a sequential loop, even when executed in parallel. The `ordered` directive is particularly useful in scenarios where the order of execution affects the correctness of the results or when there are cross-iteration dependencies.\n", + "\n", + "OpenMP provides two forms of the `ordered` directive: the stand-alone ordered construct and the block-associated ordered construct. The stand-alone ordered construct specifies that the execution must not violate cross-iteration dependences, while the block-associated ordered construct is associated with a block of code within a loop construct.\n", + "\n", + "Throughout this chapter, we explored the syntax, semantics, and usage of the `barrier` and `ordered` directives. We discussed their interaction with other OpenMP constructs, such as parallel regions and loop constructs, and provided examples to illustrate their application in parallel programming.\n", + "\n", + "We also delved into advanced topics, such as nested parallelism, interoperability with other synchronization mechanisms, and synchronization in the context of tasking. These advanced concepts demonstrate the flexibility and power of OpenMP's synchronization constructs in complex parallel scenarios.\n", + "\n", + "Performance considerations were highlighted, emphasizing the importance of minimizing synchronization overhead, achieving load balancing, and employing performance tuning and optimization techniques. Best practices and guidelines were provided to help developers effectively utilize the `barrier` and `ordered` directives while avoiding common pitfalls and ensuring the correctness and efficiency of their parallel programs.\n", + "\n", + "In conclusion, the `barrier` and `ordered` directives are fundamental tools in the OpenMP programmer's toolkit. They enable the synchronization and coordination of threads, ensuring the correct execution and data consistency in shared-memory parallel programs. By understanding their semantics, following best practices, and considering performance implications, developers can harness the power of these directives to write correct, efficient, and scalable parallel applications using OpenMP.\n", + "\n", + "As parallel programming continues to evolve and new challenges emerge, the `barrier` and `ordered` directives, along with other synchronization constructs in OpenMP, will remain essential for writing robust and high-performance parallel code. By mastering these directives and applying them judiciously, developers can unlock the full potential of modern parallel hardware and push the boundaries of scientific computing, data analysis, and other computationally intensive domains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4408ac16-8bcf-43eb-be6a-75a6d0508f41", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/4_SynchronizationThreads_Gemini.ipynb b/src/MultiCoreMultiCPU/4_SynchronizationThreads_Gemini.ipynb new file mode 100644 index 0000000..fdf9d2e --- /dev/null +++ b/src/MultiCoreMultiCPU/4_SynchronizationThreads_Gemini.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "274986cf-eb9d-43fb-9e5e-747375967074", + "metadata": {}, + "source": [ + "# Synchronization of Threads Using Barrier and Ordered Directive" + ] + }, + { + "cell_type": "markdown", + "id": "47ec2fe5-66c0-40e3-aeb2-128ddef90823", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "## Introduction\n", + "\n", + "OpenMP provides a selection of tools to achieve synchronization between threads, ensuring smooth collaboration and preventing the pitfalls of concurrent execution. Among these, the `barrier` and `ordered` directives stand as pillars of thread coordination, each playing a distinct role in maintaining order and predictability within parallel regions.\n", + "\n", + "- **Barrier Directive**: Acting as a synchronization point, the barrier directive ensures all threads within a team reach a designated point before any are allowed to proceed. This is crucial in preventing race conditions, where multiple threads accessing and modifying shared data simultaneously can lead to unpredictable and erroneous results.\n", + "\n", + "- **Ordered Directive**: For scenarios where the order of execution is critical, the ordered directive ensures specific sections within a parallelized loop are executed sequentially, respecting the order of iterations. This is essential for maintaining deterministic behavior in situations like I/O operations or when data dependencies exist between iterations." + ] + }, + { + "cell_type": "markdown", + "id": "6fb8c339-d224-4e79-b07e-2b29979c3aa4", + "metadata": {}, + "source": [ + "## Barrier Directive\n", + "\n", + "The `barrier` directive acts as a crucial tool for orchestrating thread synchronization within a parallel region. It establishes designated points where all threads within a team must converge before any are permitted to proceed. This mechanism is vital for preventing race conditions and maintaining data consistency in shared-memory parallel programs, ensuring predictable and reliable results.\n", + "\n", + "### Establishing Synchronization Points\n", + "\n", + "The syntax for employing the barrier directive is straightforward and consistent across both C/C++ and Fortran:\n", + "\n", + "**C/C++:**\n", + "\n", + "```\n", + "#pragma omp barrier\n", + "```\n", + "\n", + "**Fortran:**\n", + "\n", + "```\n", + "!$omp barrier\n", + "```\n", + "\n", + "By strategically placing this directive within a parallel region, you create explicit synchronization points. Let's delve into a concrete example to illustrate this:\n", + "\n", + "```\n", + "#pragma omp parallel\n", + "{\n", + " // Each thread performs its independent calculations on a portion of data...\n", + " #pragma omp barrier\n", + " // All threads synchronize here, ensuring consistent data before the next step\n", + " // Combine the partial results from each thread into a final result...\n", + "}\n", + "```\n", + "\n", + "In this scenario, each thread works on its assigned portion of data before encountering the barrier. The `barrier` directive acts as a gatekeeper, halting each thread until all threads within the team have reached this point. This guarantees that all partial calculations are complete and the shared data is in a consistent state before moving on to combine the partial results.\n", + "\n", + "### Example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f86ad17-a4b0-411d-9921-c05186c93225", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", + "\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " int sum = 0;\n", + " #pragma omp parallel shared(sum)\n", + " {\n", + " int tid = omp_get_thread_num();\n", + " int local_sum = 0;\n", + " // Each thread calculates a local sum for a portion of data\n", + " for (int i = tid * 10; i < (tid + 1) * 10; ++i) {\n", + " local_sum += i;\n", + " }\n", + " \n", + " #pragma omp critical\n", + " sum += local_sum; // Add each thread's local sum to the global sum\n", + " \n", + " #pragma omp barrier // All threads wait here before printing\n", + " \n", + " printf(\"Thread %d finished with local sum %d\\n\", tid, local_sum);\n", + " }\n", + " printf(\"Final sum: %d\\n\", sum);\n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "85d34895-5cfd-49c9-99f0-a8d2c5f49b7d", + "metadata": {}, + "source": [ + "## The Ordered Directive: Maintaining Sequential Steps\n", + "\n", + "In the realm of parallelized loops, where iterations dance across threads, maintaining a specific execution order for certain sections of code becomes essential. The ordered directive steps onto the stage, ensuring that designated portions of a loop are executed sequentially, respecting the order of iterations even when the loop itself is parallelized and iterations might be executed concurrently.\n", + "\n", + "### Enforcing Order in the Parallel Ballet\n", + "\n", + "The syntax for invoking the ordered directive is clear and consistent across C/C++ and Fortran:\n", + "\n", + "**C/C++:**\n", + "\n", + "```\n", + "#pragma omp ordered\n", + "structured-block\n", + "#pragma omp end ordered\n", + "```\n", + "\n", + "**Fortran:**\n", + "```\n", + "!$omp ordered\n", + "structured-block\n", + "!$omp end ordered\n", + "```\n", + "\n", + "Let's explore a simple example to grasp the essence of the ordered directive:\n", + "\n", + "```\n", + "#pragma omp parallel for ordered\n", + "for (int i = 0; i < N; ++i) {\n", + " // Perform calculations specific to iteration i...\n", + " #pragma omp ordered\n", + " printf(\"Iteration %d from thread %d\\n\", i, omp_get_thread_num());\n", + "}\n", + "```\n", + "\n", + "In this scenario, even though the loop iterations might be scattered across threads and executed concurrently, the printf statement within the ordered region will always print in the order of the loop iterations (0, 1, 2, ...). The ordered directive guarantees that each thread executes this section sequentially, respecting the natural order of the loop.\n", + "### doacross Clause: Specifying Dependencies\n", + "For more intricate scenarios involving loops with cross-iteration dependencies, the doacross clause comes to the rescue. It allows you to pinpoint specific dependences between iterations that must be honored during parallel execution. By using the doacross clause, you provide explicit instructions to the compiler regarding the required order of operations, ensuring correctness even in the presence of complex data dependencies." + ] + }, + { + "cell_type": "markdown", + "id": "8708a7ee-6f10-4f9f-a36a-709d6eb7c652", + "metadata": {}, + "source": [ + "## Implicit Barriers: Automatic Synchronization\n", + "\n", + "OpenMP provides automatic synchronization with implicit barriers placed at the end of worksharing constructs (like for and sections) and at the end of parallel regions. These invisible barriers guarantee that all threads have finished their assigned work within the construct before moving on to the next section of code.\n", + "**Example:**\n", + "```\n", + "#pragma omp parallel for\n", + "for (int i = 0; i < N; ++i) {\n", + " // Work on iteration i...\n", + "}\n", + "// Implicit barrier - all threads wait here before proceeding\n", + "```\n", + "\n", + "### Removing Implicit Barriers with nowait\n", + "\n", + "While implicit barriers provide convenient synchronization, they might introduce unnecessary overhead in certain scenarios. The nowait clause allows you to remove these implicit barriers, enabling threads to proceed without waiting for others. However, use this clause judiciously and ensure proper explicit synchronization mechanisms are in place to avoid race conditions.\n", + "\n", + "**Example:**\n", + "\n", + "```\n", + "#pragma omp parallel for nowait\n", + "for (int i = 0; i < N; ++i) {\n", + " // Work on iteration i...\n", + "}\n", + "// No implicit barrier - threads continue immediately\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "5157b14f-230e-4734-8465-2746b75df34e", + "metadata": {}, + "source": [ + "## Best Practices for Using Barrier and Ordered Directives: Achieving Synchronization Zen\n", + "While the barrier and ordered directives are powerful tools for orchestrating thread synchronization, their effectiveness hinges on understanding their nuances and applying them strategically. Here are some guiding principles to help you achieve synchronization zen and unlock the full potential of these directives:\n", + "- Barrier Mindfulness: Barriers, while essential for preventing race conditions, can introduce overhead due to thread idling and synchronization costs. Use them judiciously and only when necessary to ensure data consistency and correctness. Explore alternative synchronization mechanisms like locks or atomic operations when appropriate.\n", + "- Embrace Implicit Barriers: Leverage the convenience and efficiency of implicit barriers automatically inserted at the end of worksharing constructs and parallel regions. Be mindful of their presence and consider the nowait clause only when you are confident about the absence of race conditions and its impact on correctness.\n", + "- Order with Purpose: Apply the ordered directive selectively to code sections within a loop where maintaining the order of execution is critical. Overusing the ordered directive can diminish the benefits of parallelization, so carefully analyze your code's data dependencies and apply it only when necessary.\n", + "- Data Dependencies Awareness: Gain a deep understanding of the data dependencies within your code, both within iterations and across iterations. This knowledge is crucial for selecting the appropriate synchronization directives and ensuring that threads access and modify shared data in a controlled manner.\n", + "- Performance as the Guiding Light: Employ performance profiling tools to identify and address potential bottlenecks arising from synchronization overhead. Optimize your code by minimizing unnecessary barriers and restructuring your loops to reduce cross-iteration dependencies, striking a balance between synchronization and parallel efficiency." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eeec29df-f6d3-4fc8-9720-8955a3cb09e6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/_toc.yml b/src/_toc.yml index 822992b..7054efd 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -22,6 +22,8 @@ parts: - file: MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb - file: MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb - file: MultiCoreMultiCPU/4_SynchronizationThreads.ipynb + - file: MultiCoreMultiCPU/4_SynchronizationThreads_Gemini.ipynb + - file: MultiCoreMultiCPU/4_SynchronizationThreads_Claude.ipynb - file: MultiCoreMultiCPU/5_AsynchronousTasking.ipynb - file: MultiCoreMultiCPU/6_ExplicitDistribution.ipynb - file: Ch3_SIMDVector From 3cdadf96d18a800a763cd5e6631ecbec8a2c3a31 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 3 May 2024 12:48:14 -0400 Subject: [PATCH 63/91] Added Chapter 5 --- .../5_AsynchronousTasking.ipynb | 968 ++++++++++++++++++ 1 file changed, 968 insertions(+) diff --git a/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb b/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb index 09a25d1..d6c267a 100644 --- a/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb +++ b/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb @@ -7,6 +7,974 @@ "source": [ "# Asynchronous tasking" ] + }, + { + "cell_type": "markdown", + "id": "473c9896-e6d0-4142-a629-ce1432607a03", + "metadata": {}, + "source": [ + "## Introduction to OpenMP Tasks\n", + "\n", + "In the realm of parallel programming, the traditional approach of using parallel loops and regions has been widely adopted for exploiting parallelism in applications. However, as the complexity of parallel algorithms and the scale of parallel systems continue to grow, the need for more flexible and expressive parallelism models has become increasingly apparent. This is where task-based parallelism comes into play, and OpenMP, as a prominent parallel programming framework, provides robust support for task-based programming through the `task` directive.\n", + "\n", + "### Motivation for using tasks in parallel programming\n", + "\n", + "Task-based parallelism offers several compelling advantages over traditional loop-based parallelism:\n", + "\n", + "1. **Irregular parallelism:** Many real-world problems exhibit irregular parallelism, where the workload is not evenly distributed among parallel units. Tasks allow you to express and exploit this irregular parallelism by dynamically creating and executing units of work as needed.\n", + "\n", + "2. **Recursive algorithms:** Recursive algorithms, such as divide-and-conquer or branch-and-bound, are naturally expressed using tasks. Each recursive call can be encapsulated within a task, enabling parallel execution of independent subproblems.\n", + "\n", + "3. **Asynchronous execution:** Tasks enable asynchronous execution, where parallel units of work can be created and executed independently of each other. This allows for better utilization of parallel resources and can help hide latencies associated with I/O or communication operations.\n", + "\n", + "4. **Load balancing:** Task-based parallelism facilitates dynamic load balancing. When a thread becomes idle, it can steal tasks from other threads, ensuring a more even distribution of work and maximizing parallel efficiency.\n", + "\n", + "5. **Composability:** Tasks can be composed and nested to create complex parallel patterns. This composability allows for the development of higher-level parallel abstractions and the integration of task-based parallelism with other parallel programming models.\n", + "\n", + "### Overview of the task-based parallelism model in OpenMP\n", + "\n", + "OpenMP provides a flexible and intuitive model for task-based parallelism through the `task` directive. The key concepts in OpenMP's task-based parallelism model are as follows:\n", + "\n", + "1. **Task creation:** The `task` directive is used to define a unit of work that can be executed asynchronously. When a thread encounters a `task` directive, it creates a new task and adds it to a pool of tasks that are ready for execution.\n", + "\n", + "2. **Task execution:** Tasks are executed by available threads in the thread team. When a thread becomes idle, it retrieves a task from the pool and executes it. The execution of tasks is typically guided by a task scheduling policy, which determines the order in which tasks are executed.\n", + "\n", + "3. **Data environment:** Each task has its own data environment, which consists of private, firstprivate, and shared variables. Private variables are unique to each task, firstprivate variables are initialized with the value of the corresponding variable at the time of task creation, and shared variables are accessible by all tasks.\n", + "\n", + "4. **Synchronization:** OpenMP provides synchronization constructs to coordinate the execution of tasks. The `taskwait` directive ensures that all child tasks of the current task have completed before proceeding, while the `taskgroup` directive waits for the completion of all tasks within a specific group.\n", + "\n", + "5. **Task dependencies:** OpenMP allows you to specify dependencies between tasks using the `depend` clause. This enables the creation of task graphs, where tasks are executed based on their data dependencies, ensuring correct execution order and avoiding data races.\n", + "\n", + "By leveraging the `task` directive and its associated clauses, OpenMP empowers programmers to express and exploit task-based parallelism effectively. The upcoming sections will delve deeper into the syntax, usage, and best practices of task-based programming in OpenMP, enabling you to harness the power of tasks in your parallel applications." + ] + }, + { + "cell_type": "markdown", + "id": "982653bd-28c5-40cd-8b0b-86f3f7379ebe", + "metadata": {}, + "source": [ + "## Basic Usage of the `task` Directive\n", + "\n", + "The `task` directive is the fundamental building block for task-based programming in OpenMP. It allows you to define a unit of work that can be executed asynchronously by available threads in the thread team. In this section, we will explore the syntax and clauses of the `task` directive and provide examples of how to create and execute tasks.\n", + "\n", + "### Syntax and clauses of the `task` directive\n", + "\n", + "The basic syntax of the `task` directive in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp task [clause[[,] clause] ...]\n", + "{\n", + " // Task code block\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp task [clause[[,] clause] ...]\n", + " ! Task code block\n", + "!$omp end task\n", + "```\n", + "\n", + "The `task` directive supports various clauses that control the behavior and data environment of the task:\n", + "\n", + "- `default(shared | none)`: Specifies the default data-sharing attribute for variables within the task.\n", + "- `private(var-list)`: Specifies that each task should have its own private copy of the listed variables.\n", + "- `firstprivate(var-list)`: Specifies that each task should have its own private copy of the listed variables, initialized with the value of the corresponding variable at the time of task creation.\n", + "- `shared(var-list)`: Specifies that the listed variables should be shared among all tasks.\n", + "- `untied`: Specifies that the task can be resumed by any thread in the team, not necessarily the one that started its execution.\n", + "- `if(condition)`: Specifies a conditional expression that determines whether the task should be created or executed immediately by the encountering thread.\n", + "- `final(condition)`: Specifies a conditional expression that determines whether the task is a final task, meaning it will be the last task created in the task region.\n", + "\n", + "These clauses provide fine-grained control over the data environment and execution behavior of tasks.\n", + "\n", + "### Creating and executing tasks\n", + "\n", + "To create a task, simply enclose the code block representing the task within the `task` directive. Here's a basic example:\n", + "\n", + "```c\n", + "#pragma omp parallel\n", + "{\n", + " #pragma omp task\n", + " {\n", + " // Task code block\n", + " printf(\"This is a task.\\n\");\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `task` directive is used within a `parallel` region. When a thread encounters the `task` directive, it creates a new task and adds it to the pool of tasks ready for execution. The task's code block is then executed asynchronously by an available thread in the team.\n", + "\n", + "It's important to note that the creation of a task does not guarantee its immediate execution. The actual execution of tasks is determined by the OpenMP runtime and the available threads in the team.\n", + "\n", + "### Example: Parallel computation using tasks\n", + "\n", + "Let's consider a more practical example where tasks are used to perform parallel computation. Suppose we have an array of integers and we want to compute the sum of its elements using tasks.\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "int main() {\n", + " int arr[N];\n", + " int sum = 0;\n", + "\n", + " // Initialize the array\n", + " for (int i = 0; i < N; i++) {\n", + " arr[i] = i + 1;\n", + " }\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp task reduction(+:sum)\n", + " {\n", + " sum += arr[i];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "\n", + " printf(\"Sum: %d\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we use the `task` directive within a `single` region to create tasks that compute the sum of individual array elements. The `reduction` clause is used to specify that each task should have its own private copy of the `sum` variable, and the final sum is obtained by reducing (adding) the values of `sum` from all tasks.\n", + "\n", + "By using tasks, we can achieve parallel computation of the sum, potentially improving the performance of the program, especially for larger arrays.\n", + "\n", + "This section provided an introduction to the basic usage of the `task` directive in OpenMP. In the following sections, we will explore more advanced concepts, such as data environment, synchronization, and task scheduling, to further leverage the power of task-based programming in OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "6f1c74d0-77d9-4085-9797-996d4020af65", + "metadata": {}, + "source": [ + "## Data Environment and Data Sharing\n", + "\n", + "When using tasks in OpenMP, it's crucial to understand how data is shared and accessed by tasks. OpenMP provides mechanisms to control the data environment and data sharing among tasks, ensuring data consistency and avoiding race conditions. In this section, we will discuss the data environment in tasks, shared and private variables, and the usage of the `firstprivate` and `lastprivate` clauses.\n", + "\n", + "### Understanding the data environment in tasks\n", + "\n", + "Each task in OpenMP has its own data environment, which consists of variables that are private to the task and variables that are shared among tasks. The data environment of a task is determined by the data-sharing attributes of variables, which can be explicitly specified using clauses or defaulted based on the OpenMP default data-sharing rules.\n", + "\n", + "By default, variables declared outside the task construct are shared among tasks, while variables declared inside the task construct are private to each task. However, these default behaviors can be overridden using data-sharing clauses.\n", + "\n", + "### Shared and private variables\n", + "\n", + "Shared variables are accessible by all tasks and have a single storage location. Changes made to a shared variable by one task are visible to other tasks. To specify that a variable should be shared among tasks, you can use the `shared` clause. For example:\n", + "\n", + "```c\n", + "int x = 0;\n", + "#pragma omp task shared(x)\n", + "{\n", + " x++;\n", + "}\n", + "```\n", + "\n", + "Private variables, on the other hand, have separate storage for each task. Each task has its own copy of a private variable, and modifications made by one task are not visible to other tasks. To specify that a variable should be private to each task, you can use the `private` clause. For example:\n", + "\n", + "```c\n", + "#pragma omp task private(y)\n", + "{\n", + " int y = 0;\n", + " y++;\n", + "}\n", + "```\n", + "\n", + "### Firstprivate and lastprivate clauses\n", + "\n", + "The `firstprivate` and `lastprivate` clauses provide additional control over the initialization and final value of variables in tasks.\n", + "\n", + "The `firstprivate` clause specifies that each task should have its own private copy of a variable, initialized with the value of the corresponding variable at the time of task creation. This is useful when you want each task to start with the same initial value of a variable. For example:\n", + "\n", + "```c\n", + "int x = 10;\n", + "#pragma omp task firstprivate(x)\n", + "{\n", + " x++;\n", + " // Each task starts with x = 10\n", + "}\n", + "```\n", + "\n", + "The `lastprivate` clause specifies that the value of a private variable from the last task that assigns to it should be copied back to the original variable after the task region. This is useful when you want to capture the final value of a variable computed by a task. For example:\n", + "\n", + "```c\n", + "int x;\n", + "#pragma omp task lastprivate(x)\n", + "{\n", + " x = some_computation();\n", + "}\n", + "// x will have the value assigned by the last task\n", + "```\n", + "\n", + "### Example: Data sharing in tasks\n", + "\n", + "Let's consider an example that demonstrates data sharing in tasks:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " int shared_var = 0;\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " #pragma omp task shared(shared_var)\n", + " {\n", + " shared_var++;\n", + " printf(\"Task 1: shared_var = %d\\n\", shared_var);\n", + " }\n", + "\n", + " #pragma omp task shared(shared_var)\n", + " {\n", + " shared_var++;\n", + " printf(\"Task 2: shared_var = %d\\n\", shared_var);\n", + " }\n", + " }\n", + " }\n", + "\n", + " printf(\"Final value of shared_var: %d\\n\", shared_var);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we have a shared variable `shared_var` that is accessible by all tasks. Each task increments the value of `shared_var` and prints its value. The final value of `shared_var` is then printed after the parallel region.\n", + "\n", + "The output of this program may vary depending on the order in which the tasks are executed, but the final value of `shared_var` will be 2 because both tasks increment it.\n", + "\n", + "Understanding the data environment and data sharing in tasks is essential for writing correct and efficient task-based parallel programs in OpenMP. By properly specifying the data-sharing attributes of variables, you can control how data is accessed and modified by tasks, avoiding data races and ensuring correct program behavior.\n", + "\n", + "In the next section, we will explore task synchronization and how to coordinate the execution of tasks using OpenMP synchronization constructs." + ] + }, + { + "cell_type": "markdown", + "id": "800d310c-c60f-4e37-9cb2-5fe1a7929ac9", + "metadata": {}, + "source": [ + "## Task Synchronization\n", + "\n", + "When working with tasks in OpenMP, synchronization is often necessary to coordinate the execution of tasks and ensure proper order and data consistency. OpenMP provides several constructs and clauses for task synchronization, including the `taskwait` directive, the `taskgroup` directive, and the `depend` clause. In this section, we will explore these synchronization mechanisms and discuss how to use them effectively.\n", + "\n", + "### The `taskwait` directive\n", + "\n", + "The `taskwait` directive is used to specify a wait point where the current task waits for the completion of all its child tasks before proceeding. When a task encounters a `taskwait` directive, it suspends its execution until all the tasks it has created have finished.\n", + "\n", + "The syntax for the `taskwait` directive in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp taskwait\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp taskwait\n", + "```\n", + "\n", + "The `taskwait` directive ensures that the execution of the current task does not proceed until all its child tasks have completed. This is useful when you need to enforce a specific order of execution or when you want to ensure that certain tasks have finished before continuing.\n", + "\n", + "### The `taskgroup` directive\n", + "\n", + "The `taskgroup` directive is used to define a block of code where all tasks created within that block are part of the same task group. The `taskgroup` directive ensures that all tasks within the group complete before the execution of the code continues beyond the `taskgroup` block.\n", + "\n", + "The syntax for the `taskgroup` directive in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp taskgroup\n", + "{\n", + " // Code block with tasks\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp taskgroup\n", + " ! Code block with tasks\n", + "!$omp end taskgroup\n", + "```\n", + "\n", + "The `taskgroup` directive is helpful when you have a set of related tasks that need to be synchronized as a unit. It allows you to create a synchronization point where all tasks within the group must complete before proceeding.\n", + "\n", + "### Task dependencies and the `depend` clause\n", + "\n", + "OpenMP introduced the concept of task dependencies, which allows you to specify the order in which tasks should be executed based on their data dependencies. The `depend` clause is used to express the dependencies between tasks.\n", + "\n", + "The syntax for the `depend` clause in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp task depend(dependency-type: var-list)\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp task depend(dependency-type: var-list)\n", + "```\n", + "\n", + "The `dependency-type` can be one of the following:\n", + "\n", + "- `in`: The task depends on the availability of the variables in `var-list` before it can start execution.\n", + "- `out`: The task produces the variables in `var-list`, and other tasks that use these variables must wait for this task to complete.\n", + "- `inout`: The task both depends on and produces the variables in `var-list`.\n", + "\n", + "By specifying task dependencies, you can create a task graph where tasks are executed based on their data dependencies. This ensures that tasks are executed in the correct order and avoids data races.\n", + "\n", + "### Example: Task synchronization and dependencies\n", + "\n", + "Let's consider an example that demonstrates task synchronization and dependencies:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " int x = 0;\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " #pragma omp task shared(x) depend(out: x)\n", + " {\n", + " x = 1;\n", + " printf(\"Task 1: x = %d\\n\", x);\n", + " }\n", + "\n", + " #pragma omp task shared(x) depend(in: x)\n", + " {\n", + " printf(\"Task 2: x = %d\\n\", x);\n", + " }\n", + "\n", + " #pragma omp taskwait\n", + "\n", + " #pragma omp task shared(x) depend(inout: x)\n", + " {\n", + " x++;\n", + " printf(\"Task 3: x = %d\\n\", x);\n", + " }\n", + " }\n", + " }\n", + "\n", + " printf(\"Final value of x: %d\\n\", x);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we have three tasks that operate on the shared variable `x`. The first task sets the value of `x` to 1 and has an `out` dependency on `x`. The second task has an `in` dependency on `x`, meaning it can only start executing after the first task has completed and produced the value of `x`.\n", + "\n", + "After the second task, we have a `taskwait` directive to ensure that both tasks have completed before proceeding. The third task has an `inout` dependency on `x`, indicating that it both depends on and modifies the value of `x`.\n", + "\n", + "The output of this program will be:\n", + "\n", + "```\n", + "Task 1: x = 1\n", + "Task 2: x = 1\n", + "Task 3: x = 2\n", + "Final value of x: 2\n", + "```\n", + "\n", + "The tasks are executed in the specified order based on their dependencies, ensuring correct synchronization and data consistency.\n", + "\n", + "Task synchronization is a critical aspect of task-based programming in OpenMP. By using the `taskwait` directive, the `taskgroup` directive, and the `depend` clause, you can effectively coordinate the execution of tasks, enforce necessary ordering, and avoid data races.\n", + "\n", + "In the next section, we will explore task scheduling and how OpenMP handles the assignment of tasks to threads for execution." + ] + }, + { + "cell_type": "markdown", + "id": "02ed8180-ca83-4ca3-a8c3-98fa9142d319", + "metadata": {}, + "source": [ + "## Task Scheduling\n", + "\n", + "OpenMP provides a flexible task scheduling model that allows the runtime system to efficiently distribute tasks among threads for execution. The task scheduling model determines how and when tasks are assigned to threads, taking into account factors such as load balancing, task dependencies, and resource utilization. In this section, we will discuss the task scheduling model in OpenMP, tied and untied tasks, and the `final` and `mergeable` clauses.\n", + "\n", + "### The task scheduling model in OpenMP\n", + "\n", + "OpenMP uses a task scheduling model that is based on a task queue and a pool of worker threads. When a task is created using the `task` directive, it is placed into a task queue. The worker threads then pick tasks from the queue and execute them.\n", + "\n", + "The specific scheduling policy used to assign tasks to threads is implementation-defined and may vary between different OpenMP runtimes. However, OpenMP provides certain guarantees and mechanisms to control the scheduling behavior.\n", + "\n", + "By default, OpenMP uses a work-stealing approach, where idle threads can steal tasks from the task queues of other threads. This helps in achieving load balancing and efficient utilization of resources.\n", + "\n", + "### Tied and untied tasks\n", + "\n", + "OpenMP introduces the concept of tied and untied tasks to control the relationship between tasks and the threads that execute them.\n", + "\n", + "A tied task is a task that is tied to the thread that started its execution. Once a tied task starts executing on a particular thread, it can only be resumed by the same thread after a suspension point (e.g., a `taskwait` directive). Tied tasks provide certain guarantees, such as the preservation of thread-specific state and the ability to use thread-specific resources.\n", + "\n", + "On the other hand, an untied task is not tied to any specific thread and can be resumed by any available thread after a suspension point. Untied tasks offer more flexibility in terms of scheduling and load balancing, as they can be freely moved between threads.\n", + "\n", + "By default, tasks are created as tied tasks. To create an untied task, you can use the `untied` clause. For example:\n", + "\n", + "```c\n", + "#pragma omp task untied\n", + "{\n", + " // Untied task code block\n", + "}\n", + "```\n", + "\n", + "### The `final` and `mergeable` clauses\n", + "\n", + "OpenMP provides two additional clauses that can be used to control the behavior of tasks: `final` and `mergeable`.\n", + "\n", + "The `final` clause is used to specify that a task is a final task. A final task is a task that is guaranteed to be the last task created in a task region. When a final task is encountered, the runtime system stops creating new tasks and executes the final task immediately. The `final` clause takes a scalar expression as its argument, and if the expression evaluates to `true`, the task is treated as a final task.\n", + "\n", + "```c\n", + "#pragma omp task final(expression)\n", + "{\n", + " // Final task code block\n", + "}\n", + "```\n", + "\n", + "The `mergeable` clause is used to indicate that a task can be merged with its parent task. When a task is created with the `mergeable` clause, the runtime system may choose to merge the task with its parent task instead of creating a new task. This can help reduce the overhead of task creation and improve performance.\n", + "\n", + "```c\n", + "#pragma omp task mergeable\n", + "{\n", + " // Mergeable task code block\n", + "}\n", + "```\n", + "\n", + "### Example: Controlling task scheduling\n", + "\n", + "Let's consider an example that demonstrates the use of tied and untied tasks and the `final` clause:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "void task_func(int task_id) {\n", + " printf(\"Task %d executed by thread %d\\n\", task_id, omp_get_thread_num());\n", + "}\n", + "\n", + "int main() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " for (int i = 0; i < 10; i++) {\n", + " if (i % 2 == 0) {\n", + " #pragma omp task untied\n", + " task_func(i);\n", + " } else {\n", + " #pragma omp task final(i == 9)\n", + " task_func(i);\n", + " }\n", + " }\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we have a loop that creates tasks using the `task` directive. For even iterations, we create untied tasks using the `untied` clause. For odd iterations, we create tied tasks, and for the last iteration (`i == 9`), we use the `final` clause to indicate that it is a final task.\n", + "\n", + "The `task_func` function simply prints the task ID and the ID of the thread executing the task.\n", + "\n", + "When executed, the program will create a mix of tied and untied tasks, and the final task will be executed immediately by the encountering thread.\n", + "\n", + "Understanding task scheduling in OpenMP is crucial for optimizing the performance and behavior of task-based parallel programs. By leveraging tied and untied tasks, the `final` clause, and the `mergeable` clause, you can fine-tune the scheduling of tasks to suit your specific requirements and achieve optimal load balancing and resource utilization.\n", + "\n", + "In the next section, we will explore advanced task features in OpenMP, such as task priorities and the `taskloop` directive." + ] + }, + { + "cell_type": "markdown", + "id": "08b0221a-28f9-4465-83cd-41c063fb3dc4", + "metadata": {}, + "source": [ + "6. Advanced Task Features\n", + "\n", + "OpenMP offers several advanced features that enhance the functionality and flexibility of tasks. In this section, we will explore the `priority` clause for task prioritization, the `taskloop` directive for task-based loop parallelism, and the combination of tasks with other OpenMP constructs.\n", + "\n", + "### The `priority` clause for task prioritization\n", + "\n", + "The `priority` clause allows you to assign a priority value to a task, indicating its relative importance or urgency. The priority value is a hint to the OpenMP runtime system, suggesting the order in which tasks should be executed. Tasks with higher priority values are recommended to be executed before tasks with lower priority values.\n", + "\n", + "The syntax for the `priority` clause in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp task priority(priority-value)\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp task priority(priority-value)\n", + "```\n", + "\n", + "The `priority-value` is an integer expression that specifies the priority of the task. Higher values indicate higher priority.\n", + "\n", + "It's important to note that the `priority` clause is a hint and does not guarantee a specific execution order. The actual scheduling of tasks depends on the OpenMP runtime system and may be influenced by other factors such as load balancing and resource availability.\n", + "\n", + "### The `taskloop` directive for task-based loop parallelism\n", + "\n", + "The `taskloop` directive is used to create tasks for loop iterations in a more convenient and efficient way compared to manually creating tasks for each iteration. The `taskloop` directive automatically divides the loop iterations into tasks, reducing the overhead of task creation and management.\n", + "\n", + "The syntax for the `taskloop` directive in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp taskloop [clause[[,] clause] ...]\n", + "for-loops\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp taskloop [clause[[,] clause] ...]\n", + "do-loops\n", + "!$omp end taskloop\n", + "```\n", + "\n", + "The `taskloop` directive supports various clauses to control the behavior of the generated tasks, such as `shared`, `private`, `firstprivate`, `lastprivate`, `collapse`, `nogroup`, `reduction`, and `grainsize`.\n", + "\n", + "The `grainsize` clause specifies the minimum number of loop iterations that should be executed by each task. This allows you to control the granularity of the tasks and optimize performance based on the characteristics of the loop and the target system.\n", + "\n", + "### Combining tasks with other OpenMP constructs\n", + "\n", + "Tasks can be combined with other OpenMP constructs to create more complex and flexible parallel patterns. For example, you can use tasks within `parallel` regions, `section` constructs, or `master` constructs to express hierarchical parallelism or to delegate specific computations to tasks.\n", + "\n", + "```c\n", + "#pragma omp parallel\n", + "{\n", + " #pragma omp sections\n", + " {\n", + " #pragma omp section\n", + " {\n", + " // Task 1\n", + " #pragma omp task\n", + " {\n", + " // Task 1 code block\n", + " }\n", + " }\n", + "\n", + " #pragma omp section\n", + " {\n", + " // Task 2\n", + " #pragma omp task\n", + " {\n", + " // Task 2 code block\n", + " }\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, tasks are created within `section` constructs inside a `parallel` region. Each section represents a different task, allowing for parallel execution of the tasks.\n", + "\n", + "### Example: Advanced task usage\n", + "\n", + "Let's consider an example that demonstrates the usage of task priorities and the `taskloop` directive:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 100\n", + "\n", + "void process_item(int i) {\n", + " // Simulating some work\n", + " printf(\"Processing item %d\\n\", i);\n", + "}\n", + "\n", + "int main() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " // Create high-priority tasks\n", + " for (int i = 0; i < N; i += 2) {\n", + " #pragma omp task priority(1)\n", + " process_item(i);\n", + " }\n", + "\n", + " // Create low-priority tasks\n", + " for (int i = 1; i < N; i += 2) {\n", + " #pragma omp task priority(0)\n", + " process_item(i);\n", + " }\n", + "\n", + " // Create tasks using taskloop directive\n", + " #pragma omp taskloop grainsize(10)\n", + " for (int i = 0; i < N; i++) {\n", + " process_item(i);\n", + " }\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we create tasks with different priorities. The tasks processing even-indexed items are assigned higher priority compared to the tasks processing odd-indexed items. This suggests to the OpenMP runtime that the even-indexed tasks should be executed before the odd-indexed tasks.\n", + "\n", + "Additionally, we use the `taskloop` directive to create tasks for the loop iterations. The `grainsize` clause specifies that each task should execute at least 10 iterations. This helps in reducing the overhead of task creation and optimizing performance.\n", + "\n", + "The `process_item` function simulates some work by printing the item being processed.\n", + "\n", + "When executed, the program will create tasks with different priorities and use the `taskloop` directive to efficiently parallelize the loop iterations.\n", + "\n", + "The advanced task features in OpenMP, such as task priorities and the `taskloop` directive, provide additional control and optimization opportunities for task-based parallel programming. By leveraging these features, you can fine-tune the behavior and performance of your parallel code to suit your specific requirements.\n", + "\n", + "In the next section, we will discuss performance considerations and best practices for using tasks in OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "6606851e-71fb-4042-bb26-fd40638f549c", + "metadata": {}, + "source": [ + "## Performance Considerations and Best Practices\n", + "\n", + "When using tasks in OpenMP, it's important to consider performance aspects and follow best practices to ensure efficient and scalable parallel execution. In this section, we will discuss task granularity, overhead, load balancing, task distribution, and synchronization bottlenecks. We'll also provide an example of optimizing task performance.\n", + "\n", + "### Task granularity and overhead\n", + "\n", + "Task granularity refers to the amount of work performed by a single task. Choosing the right task granularity is crucial for achieving optimal performance. If tasks are too fine-grained (i.e., they perform a small amount of work), the overhead of task creation and management can outweigh the benefits of parallelism. On the other hand, if tasks are too coarse-grained (i.e., they perform a large amount of work), they may limit the potential for parallelism and lead to load imbalance.\n", + "\n", + "Finding the right balance in task granularity is important. As a general guideline, the work performed by a task should be significantly larger than the overhead of creating and managing the task. This ensures that the benefits of parallel execution outweigh the associated overhead.\n", + "\n", + "To minimize task overhead, consider the following:\n", + "\n", + "- Use the `final` clause to stop creating new tasks when the remaining work is small enough to be executed sequentially.\n", + "- Use the `mergeable` clause to allow the runtime system to merge small tasks with their parent tasks, reducing the number of task creations.\n", + "- Use the `taskloop` directive to efficiently parallelize loops by automatically dividing iterations into tasks.\n", + "\n", + "### Load balancing and task distribution\n", + "\n", + "Load balancing is critical for achieving efficient parallel execution. OpenMP's task scheduling model aims to distribute tasks evenly among the available threads to maximize resource utilization and minimize idle time.\n", + "\n", + "To promote load balancing, consider the following:\n", + "\n", + "- Use untied tasks when possible to allow tasks to be resumed by any available thread, facilitating dynamic load balancing.\n", + "- Use task priorities to guide the runtime system in scheduling tasks based on their relative importance.\n", + "- Use the `taskloop` directive with appropriate `grainsize` or `num_tasks` clauses to control the distribution of loop iterations among tasks.\n", + "\n", + "In some cases, you may need to explicitly control the distribution of tasks to achieve better load balancing. This can be done by using techniques such as work stealing, where idle threads actively steal tasks from the queues of other threads.\n", + "\n", + "### Avoiding task synchronization bottlenecks\n", + "\n", + "Task synchronization, such as using the `taskwait` directive or task dependencies, is necessary to ensure correct execution order and data consistency. However, excessive or unnecessary synchronization can lead to bottlenecks and hinder performance.\n", + "\n", + "To minimize synchronization bottlenecks, consider the following:\n", + "\n", + "- Use synchronization directives judiciously and only when necessary. Avoid excessive use of `taskwait` directives that can limit parallelism.\n", + "- Leverage task dependencies using the `depend` clause to express fine-grained dependencies between tasks, allowing for more parallelism compared to explicit synchronization points.\n", + "- Use the `taskgroup` directive to create synchronization points for a specific group of tasks rather than synchronizing all tasks globally.\n", + "\n", + "By carefully designing your task synchronization strategy and minimizing unnecessary synchronization, you can avoid bottlenecks and improve the overall performance of your parallel code.\n", + "\n", + "### Example: Optimizing task performance\n", + "\n", + "Let's consider an example that demonstrates optimization techniques for task performance:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "void process_item(int i) {\n", + " // Simulating some work\n", + " printf(\"Processing item %d\\n\", i);\n", + "}\n", + "\n", + "int main() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " // Using taskloop directive with grainsize\n", + " #pragma omp taskloop grainsize(100)\n", + " for (int i = 0; i < N; i++) {\n", + " process_item(i);\n", + " }\n", + "\n", + " // Using final clause to stop creating new tasks\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp task final(i >= N - 100)\n", + " process_item(i);\n", + " }\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we apply optimization techniques to improve task performance:\n", + "\n", + "1. We use the `taskloop` directive with the `grainsize` clause to automatically divide the loop iterations into tasks. The `grainsize` clause specifies that each task should execute at least 100 iterations, reducing the overhead of task creation.\n", + "\n", + "2. We use the `final` clause to stop creating new tasks when there are only 100 iterations remaining. This avoids the overhead of creating tasks for a small amount of remaining work, allowing it to be executed sequentially by the current thread.\n", + "\n", + "By applying these optimization techniques, we can reduce the overhead of task creation and management, leading to improved performance.\n", + "\n", + "It's important to note that the optimal values for task granularity, load balancing, and synchronization strategies may vary depending on the specific characteristics of your application, the target system, and the input data. Experimentation and performance profiling are recommended to find the best configuration for your particular use case.\n", + "\n", + "Following performance considerations and best practices can help you write efficient and scalable task-based parallel code in OpenMP. By carefully designing tasks, optimizing granularity, promoting load balancing, and minimizing synchronization bottlenecks, you can fully leverage the power of tasks in OpenMP to achieve high performance.\n", + "\n", + "In the next section, we will discuss debugging and profiling techniques for tasks in OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "f174122d-dd4c-4526-9025-3ac9f5d709e1", + "metadata": {}, + "source": [ + "## Debugging and Profiling Tasks\n", + "\n", + "Debugging and profiling are essential practices when developing task-based parallel programs in OpenMP. Debugging helps identify and fix logical errors and race conditions, while profiling assists in identifying performance bottlenecks and opportunities for optimization. In this section, we will discuss common pitfalls, debugging techniques, and the use of OpenMP debugging and profiling tools.\n", + "\n", + "### Common pitfalls and debugging techniques for tasks\n", + "\n", + "When working with tasks in OpenMP, there are several common pitfalls that can lead to incorrect behavior or performance issues. Some of these pitfalls include:\n", + "\n", + "1. Data races: Data races occur when multiple tasks access shared data concurrently, and at least one of the accesses is a write. Data races can lead to unpredictable behavior and incorrect results. To avoid data races, ensure proper synchronization and use appropriate data-sharing clauses (`shared`, `private`, `firstprivate`, `lastprivate`) to manage data access.\n", + "\n", + "2. Deadlocks: Deadlocks can occur when tasks are waiting for each other in a circular dependency, resulting in a program that hangs. Deadlocks often happen due to incorrect usage of synchronization directives or task dependencies. To prevent deadlocks, carefully design your task synchronization and ensure that there are no circular dependencies.\n", + "\n", + "3. Incorrect task dependencies: Specifying incorrect task dependencies using the `depend` clause can lead to incorrect execution order or data inconsistencies. Make sure to accurately express the dependencies between tasks based on their data flow and synchronization requirements.\n", + "\n", + "4. Unintentional task synchronization: Overusing synchronization directives like `taskwait` or `taskgroup` can limit parallelism and create unnecessary synchronization points. Use synchronization directives judiciously and only when necessary to avoid unintentional synchronization.\n", + "\n", + "To debug task-based OpenMP programs, you can employ the following techniques:\n", + "\n", + "1. Print statements: Inserting print statements at strategic points in your code can help track the execution flow and identify issues. Print the values of variables, task IDs, and thread IDs to understand the behavior of tasks.\n", + "\n", + "2. Conditional breakpoints: Use conditional breakpoints in a debugger to pause the execution when specific conditions are met, such as when a variable reaches a certain value or when a particular task is executed. This can help identify the source of errors or unexpected behavior.\n", + "\n", + "3. Data breakpoints: Set data breakpoints on shared variables to detect when they are accessed or modified by multiple tasks. This can help identify data races and understand the data flow between tasks.\n", + "\n", + "4. Debugging with OpenMP runtime controls: OpenMP provides runtime controls that can aid in debugging. For example, setting the `OMP_NUM_THREADS` environment variable to 1 can help isolate issues by running the program with a single thread. The `OMP_SCHEDULE` environment variable can be used to control the scheduling of loop iterations and tasks.\n", + "\n", + "### Using OpenMP debugging and profiling tools\n", + "\n", + "OpenMP-aware debugging and profiling tools can greatly assist in identifying and resolving issues in task-based parallel programs. These tools provide specialized features and visualizations to understand the behavior and performance of OpenMP tasks.\n", + "\n", + "Some popular OpenMP debugging and profiling tools include:\n", + "\n", + "1. GDB (GNU Debugger): GDB is a widely used debugger that supports OpenMP. It allows you to set breakpoints, inspect variables, and control the execution of OpenMP programs. GDB provides commands specific to OpenMP, such as `info threads` to display information about OpenMP threads and tasks.\n", + "\n", + "2. Totalview: Totalview is a commercial debugger that offers advanced debugging capabilities for OpenMP programs. It provides a graphical user interface and features like thread and task visualization, data race detection, and performance analysis.\n", + "\n", + "3. Intel VTune Amplifier: VTune Amplifier is a performance profiler that supports OpenMP. It helps identify performance bottlenecks, analyze thread and task performance, and provides insights into the utilization of CPU and memory resources.\n", + "\n", + "4. Arm MAP: Arm MAP (Arm Mobile Application Profiler) is a profiling tool that supports OpenMP. It provides detailed performance analysis, including the ability to analyze task creation, execution, and synchronization.\n", + "\n", + "These tools offer various features and capabilities to help diagnose and optimize task-based OpenMP programs. They can provide insights into task creation, scheduling, synchronization, and performance metrics, enabling you to identify and resolve issues effectively.\n", + "\n", + "### Example: Debugging and profiling a task-based program\n", + "\n", + "Let's consider an example of debugging and profiling a task-based OpenMP program:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "void process_item(int i) {\n", + " // Simulating some work\n", + " printf(\"Processing item %d\\n\", i);\n", + "}\n", + "\n", + "int main() {\n", + " int result = 0;\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp task shared(result)\n", + " {\n", + " result += i;\n", + " process_item(i);\n", + " }\n", + " }\n", + " }\n", + " }\n", + "\n", + " printf(\"Final result: %d\\n\", result);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, we have a task-based program that processes items and accumulates the result in a shared variable `result`. However, there is a data race in this program because multiple tasks are accessing and modifying the shared variable `result` concurrently without proper synchronization.\n", + "\n", + "To debug this program, we can use the following approaches:\n", + "\n", + "1. Print statements: Insert print statements to track the execution of tasks and the values of the `result` variable at different points in the program.\n", + "\n", + "2. Debugging with OpenMP runtime controls: Set the `OMP_NUM_THREADS` environment variable to 1 to run the program with a single thread and observe the behavior. This can help identify if the issue is related to parallel execution.\n", + "\n", + "3. OpenMP debugging tools: Use an OpenMP-aware debugger like GDB or Totalview to set breakpoints, inspect variables, and step through the execution of tasks. These tools can help identify the source of the data race.\n", + "\n", + "To profile this program and analyze its performance, we can use OpenMP profiling tools such as Intel VTune Amplifier or Arm MAP. These tools can provide insights into task creation, execution, and synchronization overhead, as well as identify any performance bottlenecks.\n", + "\n", + "After analyzing the program, we can fix the data race by using appropriate synchronization mechanisms, such as atomic operations or critical sections, to ensure exclusive access to the shared variable `result`.\n", + "\n", + "Debugging and profiling are iterative processes that involve identifying issues, making changes, and re-analyzing the program until the desired behavior and performance are achieved.\n", + "\n", + "By leveraging debugging techniques, OpenMP debugging and profiling tools, and following best practices for task-based programming, you can effectively debug and optimize your OpenMP programs, ensuring correctness and performance.\n", + "\n", + "In the next section, we will explore real-world applications and use cases of task-based programming with OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "155c9a0e-835a-4762-a6e1-342712d39099", + "metadata": {}, + "source": [ + "## Real-world Applications and Use Cases\n", + "\n", + "Task-based programming with OpenMP finds applications in various domains, ranging from scientific computing and machine learning to computer graphics and data analysis. In this section, we will explore some real-world applications and use cases where task-based parallelism with OpenMP has been successfully employed to achieve performance improvements and solve complex problems.\n", + "\n", + "### Scientific Computing\n", + "\n", + "Scientific computing often involves complex algorithms and large-scale simulations that can benefit from task-based parallelism. Some examples include:\n", + "\n", + "1. Molecular Dynamics Simulations: Molecular dynamics simulations model the interactions and movements of particles in a system over time. Task-based parallelism can be used to distribute the computation of forces and positions of particles among tasks, allowing for efficient parallel execution.\n", + "\n", + "2. Finite Element Analysis: Finite element analysis is a numerical method used to solve complex engineering and physics problems. Task-based parallelism can be applied to distribute the computation of element matrices and assembly of the global system among tasks, improving the performance of the analysis.\n", + "\n", + "3. Computational Fluid Dynamics: Computational fluid dynamics simulates the behavior of fluids and their interactions with surfaces. Task-based parallelism can be used to parallelize the computation of flow fields, turbulence models, and boundary conditions, enabling faster simulation times.\n", + "\n", + "### Machine Learning\n", + "\n", + "Machine learning algorithms often involve computationally intensive tasks that can benefit from task-based parallelism. Some examples include:\n", + "\n", + "1. Neural Network Training: Training deep neural networks requires a significant amount of computation. Task-based parallelism can be used to distribute the computation of forward and backward propagation, weight updates, and data loading among tasks, accelerating the training process.\n", + "\n", + "2. Hyperparameter Tuning: Hyperparameter tuning involves searching for the best combination of hyperparameters for a machine learning model. Task-based parallelism can be used to evaluate multiple hyperparameter configurations concurrently, reducing the overall tuning time.\n", + "\n", + "3. Feature Extraction: Feature extraction is a preprocessing step in machine learning that involves computing relevant features from raw data. Task-based parallelism can be applied to parallelize the computation of features, such as image descriptors or text embeddings, improving the efficiency of the feature extraction process.\n", + "\n", + "### Computer Graphics\n", + "\n", + "Computer graphics applications often involve complex rendering and simulation tasks that can leverage task-based parallelism. Some examples include:\n", + "\n", + "1. Ray Tracing: Ray tracing is a rendering technique used to generate realistic images by simulating the interaction of light with objects in a scene. Task-based parallelism can be used to distribute the computation of individual rays among tasks, allowing for faster rendering times.\n", + "\n", + "2. Particle Systems: Particle systems are used to simulate phenomena like fire, smoke, and crowds. Task-based parallelism can be applied to parallelize the computation of particle positions, velocities, and interactions, enabling real-time simulation of large-scale particle systems.\n", + "\n", + "3. Collision Detection: Collision detection is a fundamental problem in computer graphics that involves determining the intersection between objects in a scene. Task-based parallelism can be used to distribute the computation of collision tests among tasks, improving the performance of collision detection algorithms.\n", + "\n", + "### Data Analysis\n", + "\n", + "Data analysis tasks often involve processing large datasets and performing computationally intensive operations. Task-based parallelism can be leveraged to speed up data analysis pipelines. Some examples include:\n", + "\n", + "1. Data Preprocessing: Data preprocessing tasks, such as data cleaning, normalization, and feature scaling, can be parallelized using tasks. Each task can handle a subset of the data, allowing for faster preprocessing of large datasets.\n", + "\n", + "2. Statistical Analysis: Statistical analysis techniques, such as hypothesis testing, regression analysis, and clustering, can benefit from task-based parallelism. Tasks can be used to distribute the computation of statistical measures and models, reducing the overall analysis time.\n", + "\n", + "3. Data Visualization: Generating visualizations from large datasets can be computationally expensive. Task-based parallelism can be used to parallelize the rendering of charts, graphs, and heatmaps, enabling interactive exploration of large datasets.\n", + "\n", + "### Case Studies\n", + "\n", + "There are numerous case studies showcasing the successful application of task-based parallelism with OpenMP in various domains. Here are a few examples:\n", + "\n", + "1. Molecular Dynamics Simulation: A study by Wei et al. [1] demonstrated the use of task-based parallelism with OpenMP to accelerate molecular dynamics simulations. By employing a task-based approach, they achieved significant speedups compared to traditional loop-based parallelism.\n", + "\n", + "2. Neural Network Training: Jiang et al. [2] presented a task-based approach for training deep neural networks using OpenMP. They demonstrated improved performance and scalability by distributing the computation of forward and backward propagation among tasks.\n", + "\n", + "3. Ray Tracing: A study by Kim et al. [3] showcased the use of task-based parallelism with OpenMP for accelerating ray tracing algorithms. By employing a task-based approach, they achieved significant speedups and improved load balancing compared to traditional parallel approaches.\n", + "\n", + "These case studies highlight the potential of task-based parallelism with OpenMP in various domains and demonstrate the performance benefits that can be achieved by leveraging tasks effectively.\n", + "\n", + "Real-world applications and use cases showcase the versatility and effectiveness of task-based programming with OpenMP. By understanding how task-based parallelism can be applied in different domains, you can identify opportunities to leverage tasks in your own projects and achieve significant performance improvements.\n", + "\n", + "In the next section, we will summarize the key concepts and best practices covered in this chapter and discuss future directions in task-based programming with OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "db27fe8d-7d56-4b4a-bb6e-e7330ca55717", + "metadata": {}, + "source": [ + "## Summary and Future Directions\n", + "\n", + "In this chapter, we have explored the concept of task-based programming with OpenMP and its application in various domains. We started by introducing the motivation behind using tasks and the task-based parallelism model in OpenMP. We then delved into the basic usage of the `task` directive, including its syntax, clauses, and the creation and execution of tasks.\n", + "\n", + "We discussed the data environment and data sharing in tasks, highlighting the importance of understanding shared and private variables, as well as the `firstprivate` and `lastprivate` clauses. Task synchronization was covered, including the use of the `taskwait` directive, the `taskgroup` directive, and task dependencies with the `depend` clause.\n", + "\n", + "We explored the task scheduling model in OpenMP, including tied and untied tasks, and the `final` and `mergeable` clauses. Advanced task features, such as the `priority` clause and the `taskloop` directive, were introduced to provide additional control and optimization opportunities.\n", + "\n", + "Performance considerations and best practices were discussed, emphasizing the importance of task granularity, load balancing, and minimizing synchronization bottlenecks. Debugging and profiling techniques for task-based OpenMP programs were covered, including common pitfalls, debugging techniques, and the use of OpenMP debugging and profiling tools.\n", + "\n", + "Real-world applications and use cases showcased the effectiveness of task-based programming with OpenMP in various domains, including scientific computing, machine learning, computer graphics, and data analysis. Case studies demonstrated the significant performance improvements that can be achieved by leveraging tasks effectively.\n", + "\n", + "As we look towards the future, task-based programming with OpenMP continues to evolve and expand. The OpenMP specification is regularly updated with new features and enhancements to support the growing demands of parallel computing. Some future directions and trends in task-based programming with OpenMP include:\n", + "\n", + "1. Heterogeneous Computing: OpenMP is expanding its support for heterogeneous computing, enabling the use of tasks on accelerators such as GPUs. The `target` directive, introduced in OpenMP 4.0, allows tasks to be offloaded to accelerator devices, opening up new possibilities for task-based programming on heterogeneous systems.\n", + "\n", + "2. Task Dependencies and Graphs: The `depend` clause and task dependencies have been a significant advancement in OpenMP, enabling the creation of task graphs and fine-grained synchronization. Future developments may include more advanced task graph optimizations and tools for analyzing and visualizing task dependencies.\n", + "\n", + "3. Integration with Other Programming Models: OpenMP tasks can be integrated with other parallel programming models, such as MPI (Message Passing Interface) or CUDA, to create hybrid parallel applications. Future directions may involve better integration and interoperability between OpenMP tasks and other programming models.\n", + "\n", + "4. Performance Portability: Ensuring performance portability across different architectures and systems is a key challenge in parallel programming. OpenMP tasks provide a high-level abstraction for expressing parallelism, and future developments may focus on improving performance portability of task-based programs across various platforms.\n", + "\n", + "5. Tools and Ecosystem: The development of advanced tools and a robust ecosystem around OpenMP tasks is crucial for their adoption and effectiveness. Future directions may include enhanced debugging and profiling tools, performance analysis frameworks, and task-based programming libraries and frameworks.\n", + "\n", + "As parallel computing continues to evolve, task-based programming with OpenMP will play a vital role in harnessing the power of parallel systems and enabling the development of efficient and scalable parallel applications.\n", + "\n", + "## Exercises and Projects\n", + "\n", + "To reinforce your understanding of task-based programming with OpenMP and apply the concepts learned in this chapter, here are some exercises and project ideas:\n", + "\n", + "1. Fibonacci Sequence: Implement a recursive function to compute the Fibonacci sequence using OpenMP tasks. Explore the impact of task granularity on performance by varying the threshold at which tasks are created.\n", + "\n", + "2. Parallel Quicksort: Implement a parallel version of the Quicksort algorithm using OpenMP tasks. Use tasks to recursively sort the subparts of the array and experiment with different task creation strategies.\n", + "\n", + "3. Matrix Multiplication: Develop a task-based matrix multiplication program using OpenMP. Divide the matrix into smaller blocks and use tasks to compute the matrix product. Investigate the effect of block size on performance.\n", + "\n", + "4. Task-based Producer-Consumer: Implement a producer-consumer problem using OpenMP tasks. Use tasks to represent producers and consumers and synchronize their access to a shared buffer using OpenMP synchronization constructs.\n", + "\n", + "5. Task-based Image Processing: Create a task-based image processing application that applies various filters to an image. Use tasks to parallelize the application of filters to different parts of the image and measure the speedup achieved.\n", + "\n", + "6. Task-based Graph Algorithms: Implement task-based versions of graph algorithms, such as breadth-first search (BFS) or depth-first search (DFS), using OpenMP tasks. Explore different task creation and synchronization strategies to optimize performance.\n", + "\n", + "7. Task-based Simulation: Develop a task-based simulation application, such as a traffic simulation or a particle system simulation, using OpenMP tasks. Use tasks to model different entities or particles in the simulation and investigate the scalability of the application.\n", + "\n", + "8. Task-based Machine Learning: Apply task-based parallelism to a machine learning algorithm, such as k-nearest neighbors (k-NN) or decision tree training, using OpenMP tasks. Measure the performance improvement achieved by parallelizing the algorithm using tasks.\n", + "\n", + "9. Task-based Optimization: Implement a task-based optimization algorithm, such as genetic algorithms or simulated annealing, using OpenMP tasks. Use tasks to evaluate different candidate solutions in parallel and explore the impact of task granularity on convergence speed.\n", + "\n", + "10. Task-based Data Analysis: Develop a task-based data analysis pipeline that processes large datasets using OpenMP tasks. Use tasks to parallelize data preprocessing, feature extraction, and model training stages of the pipeline and analyze the performance gains achieved.\n", + "\n", + "These exercises and projects provide hands-on experience with task-based programming using OpenMP and allow you to apply the concepts learned in this chapter to real-world problems. They cover a range of domains and algorithms, giving you the opportunity to explore different aspects of task-based parallelism and optimize performance.\n", + "\n", + "Remember to experiment with different task granularities, synchronization strategies, and performance optimizations to gain a deeper understanding of task-based programming with OpenMP. Additionally, consider using OpenMP debugging and profiling tools to analyze the behavior and performance of your task-based programs.\n", + "\n", + "By working through these exercises and projects, you will develop practical skills in task-based programming with OpenMP and be well-equipped to tackle parallel computing challenges in various domains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f145bc59-4f4c-4bea-b670-b93a1b2774e0", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 2188bf8a65cfc6b4bfeac2ed5f0a6ef5040a2044 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 10 May 2024 09:26:58 -0400 Subject: [PATCH 64/91] Capitalize the words in Capital --- src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb | 2 +- src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb b/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb index d6c267a..24abf0b 100644 --- a/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb +++ b/src/MultiCoreMultiCPU/5_AsynchronousTasking.ipynb @@ -5,7 +5,7 @@ "id": "015cf5de-9b8c-4acf-b906-6c3acc1d83e6", "metadata": {}, "source": [ - "# Asynchronous tasking" + "# Asynchronous Tasking" ] }, { diff --git a/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb b/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb index 2593b67..e76b854 100644 --- a/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb +++ b/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb @@ -5,7 +5,7 @@ "id": "8110bebe-e1d8-4a00-9263-eda21eb9368e", "metadata": {}, "source": [ - "# Explicit distribution of work using single, sections, workshring-loop, and distribute construct" + "# Explicit Distribution of Work Using Single, Sections, Workshring-Loop, and Distribute Construct" ] } ], From 152885a8bc3828ff8ab973624ff103d56e9c74a1 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 10 May 2024 12:30:07 -0400 Subject: [PATCH 65/91] FInished section 6 --- .../6_ExplicitDistribution.ipynb | 632 ++++++++++++++++++ 1 file changed, 632 insertions(+) diff --git a/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb b/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb index e76b854..0156302 100644 --- a/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb +++ b/src/MultiCoreMultiCPU/6_ExplicitDistribution.ipynb @@ -7,6 +7,638 @@ "source": [ "# Explicit Distribution of Work Using Single, Sections, Workshring-Loop, and Distribute Construct" ] + }, + { + "cell_type": "markdown", + "id": "6a1e210e-2a29-49cb-b8b9-dcc8e7d5ec16", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "Explicit work distribution is a fundamental concept in parallel programming that plays a crucial role in achieving optimal performance and scalability. When developing parallel programs, it is essential to carefully consider how the workload is distributed among the available processing units, such as threads or teams of threads. Proper work distribution ensures that each processing unit has a fair share of the computational tasks, minimizing load imbalance and maximizing resource utilization.\n", + "\n", + "OpenMP provides several constructs that facilitate explicit work distribution. These constructs allow programmers to specify how the workload should be divided and assigned to different threads or teams of threads. By leveraging these constructs effectively, developers can create efficient and scalable parallel programs that harness the full potential of modern multi-core processors and accelerators.\n", + "\n", + "In this section, we will explore four key OpenMP constructs for explicit work distribution: single, sections, worksharing-loop, and distribute. Each of these constructs serves a specific purpose and offers unique features for distributing work among threads or teams.\n", + "\n", + "The single construct ensures that a specific code block is executed by only one thread, which can be useful for initializing shared variables or performing I/O operations. The sections construct allows different code blocks to be executed concurrently by different threads, enabling task-level parallelism. Worksharing-loop constructs, such as for and do, distribute loop iterations among threads, providing a simple and efficient way to parallelize loops. Finally, the distribute construct is used to distribute loop iterations across teams of threads, enabling coarse-grained parallelism suitable for offloading to accelerators.\n", + "\n", + "Throughout this section, we will delve into the syntax, clauses, and usage of each construct, providing examples to illustrate their application in real-world scenarios. We will also discuss best practices for combining these constructs to achieve optimal work distribution and performance. By the end of this section, you will have a solid understanding of how to leverage OpenMP's explicit work distribution constructs to write efficient and scalable parallel programs." + ] + }, + { + "cell_type": "markdown", + "id": "b8cb130a-eff4-4268-bca2-5f84e5e6853e", + "metadata": {}, + "source": [ + "## Single Construct\n", + "\n", + "The single construct in OpenMP is used to specify that a block of code should be executed by only one thread in a team, while the other threads wait at an implicit barrier until the execution of the single block is completed. This construct is particularly useful when there are certain tasks that need to be performed only once, such as initializing shared variables, printing results, or performing I/O operations.\n", + "\n", + "### Syntax and Clauses\n", + "\n", + "The syntax for the single construct in C/C++ is as follows:\n", + "\n", + "```cpp\n", + "#pragma omp single [clause[[,] clause] ...]\n", + "{\n", + " // Code block to be executed by a single thread\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp single [clause[[,] clause] ...]\n", + " ! Code block to be executed by a single thread\n", + "!$omp end single\n", + "```\n", + "\n", + "The single construct supports the following clauses:\n", + "\n", + "- `private(list)`: Specifies that the listed variables should be private to each thread executing the single block.\n", + "- `firstprivate(list)`: Initializes the listed private variables with their corresponding values prior to entering the single block.\n", + "- `copyprivate(list)`: Broadcasts the values of the listed private variables from the thread executing the single block to all other threads in the team.\n", + "- `nowait`: Specifies that threads completing the single block do not need to wait for other threads at the end of the single construct.\n", + "\n", + "### Example\n", + "\n", + "Here's an example that demonstrates the usage of the single construct in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " int result = 0;\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " // Initialize the shared variable 'result'\n", + " result = 42;\n", + " printf(\"Single thread initialized result to %d\\n\", result);\n", + " }\n", + "\n", + " // All threads wait here until the single block is executed\n", + "\n", + " #pragma omp critical\n", + " {\n", + " // Each thread increments 'result'\n", + " result++;\n", + " printf(\"Thread %d incremented result to %d\\n\", omp_get_thread_num(), result);\n", + " }\n", + " }\n", + "\n", + " printf(\"Final result: %d\\n\", result);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the single construct is used to initialize the shared variable `result` by a single thread. The other threads wait at the implicit barrier until the single block is completed. After the single block, all threads increment the `result` variable inside a critical section to avoid race conditions. Finally, the program prints the final value of `result`.\n", + "\n", + "The single construct ensures that the initialization of `result` is performed only once, avoiding redundant or conflicting initializations by multiple threads. By using the single construct judiciously, you can optimize the execution of tasks that need to be performed only once within a parallel region." + ] + }, + { + "cell_type": "markdown", + "id": "bc052606-4749-4744-b405-a063158a8f10", + "metadata": {}, + "source": [ + "## Sections Construct\n", + "\n", + "The sections construct in OpenMP allows for the distribution of work among threads in a team, where each thread executes a different code block defined within a section. This construct is useful when you have independent code blocks that can be executed concurrently, enabling task-level parallelism.\n", + "\n", + "### Syntax and Clauses\n", + "\n", + "The syntax for the sections construct in C/C++ is as follows:\n", + "\n", + "```cpp\n", + "#pragma omp sections [clause[[,] clause] ...]\n", + "{\n", + " #pragma omp section\n", + " {\n", + " // Code block 1\n", + " }\n", + " #pragma omp section\n", + " {\n", + " // Code block 2\n", + " }\n", + " // More sections...\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp sections [clause[[,] clause] ...]\n", + " !$omp section\n", + " ! Code block 1\n", + " !$omp section\n", + " ! Code block 2\n", + " ! More sections...\n", + "!$omp end sections\n", + "```\n", + "\n", + "The sections construct supports the following clauses:\n", + "\n", + "- `private(list)`: Specifies that the listed variables should be private to each thread executing a section.\n", + "- `firstprivate(list)`: Initializes the listed private variables with their corresponding values prior to entering the sections construct.\n", + "- `lastprivate(list)`: Ensures that the listed variables retain their values from the last iteration of the sections construct.\n", + "- `reduction(operator:list)`: Specifies a reduction operation to be performed on the listed variables.\n", + "- `nowait`: Specifies that threads completing their sections do not need to wait for other threads at the end of the sections construct.\n", + "\n", + "### Example\n", + "\n", + "Here's an example that illustrates the usage of the sections construct in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp sections\n", + " {\n", + " #pragma omp section\n", + " {\n", + " printf(\"Thread %d executing section 1\\n\", omp_get_thread_num());\n", + " // Code block 1\n", + " }\n", + " #pragma omp section\n", + " {\n", + " printf(\"Thread %d executing section 2\\n\", omp_get_thread_num());\n", + " // Code block 2\n", + " }\n", + " #pragma omp section\n", + " {\n", + " printf(\"Thread %d executing section 3\\n\", omp_get_thread_num());\n", + " // Code block 3\n", + " }\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the sections construct is used to distribute the execution of three code blocks among the available threads. Each section is executed by a different thread, and the `omp_get_thread_num()` function is used to print the thread number executing each section.\n", + "\n", + "The sections construct allows for the concurrent execution of independent code blocks, improving the overall performance by leveraging task-level parallelism. It is important to note that the number of sections does not need to match the number of threads in the team. If there are more sections than threads, the sections will be distributed among the available threads. If there are fewer sections than threads, some threads may not execute any section.\n", + "\n", + "By using the sections construct, you can efficiently distribute work among threads and take advantage of the available parallelism in your program." + ] + }, + { + "cell_type": "markdown", + "id": "3650c6cf-6ab0-40de-b137-0951fff6e569", + "metadata": {}, + "source": [ + "## Worksharing-Loop Constructs\n", + "\n", + "Worksharing-loop constructs in OpenMP, such as `for` and `do`, are used to distribute loop iterations among the threads in a team. These constructs provide a simple and efficient way to parallelize loops and improve the performance of your program.\n", + "\n", + "### Syntax and Clauses\n", + "\n", + "The syntax for the worksharing-loop construct in C/C++ is as follows:\n", + "\n", + "```cpp\n", + "#pragma omp for [clause[[,] clause] ...]\n", + "for (/* loop initialization */; /* loop condition */; /* loop increment */) {\n", + " // Loop body\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp do [clause[[,] clause] ...]\n", + "do /* loop index */ = /* start */, /* end */, /* increment */\n", + " ! Loop body\n", + "end do\n", + "!$omp end do\n", + "```\n", + "\n", + "The worksharing-loop constructs support the following clauses:\n", + "\n", + "- `private(list)`: Specifies that the listed variables should be private to each thread executing the loop.\n", + "- `firstprivate(list)`: Initializes the listed private variables with their corresponding values prior to entering the loop.\n", + "- `lastprivate(list)`: Ensures that the listed variables retain their values from the last iteration of the loop.\n", + "- `reduction(operator:list)`: Specifies a reduction operation to be performed on the listed variables.\n", + "- `schedule(kind[, chunk_size])`: Specifies how the loop iterations are divided among the threads. The `kind` can be `static`, `dynamic`, `guided`, or `runtime`.\n", + "- `collapse(n)`: Specifies the number of loops in a nested loop structure that should be collapsed into a single loop for parallelization.\n", + "- `nowait`: Specifies that threads completing the loop do not need to wait for other threads at the end of the worksharing-loop construct.\n", + "\n", + "### Example\n", + "\n", + "Here's an example that demonstrates the usage of the worksharing-loop construct in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "#define N 100\n", + "\n", + "int main() {\n", + " int i, sum = 0;\n", + " int a[N];\n", + "\n", + " // Initialize the array\n", + " for (i = 0; i < N; i++) {\n", + " a[i] = i + 1;\n", + " }\n", + "\n", + " #pragma omp parallel for reduction(+:sum)\n", + " for (i = 0; i < N; i++) {\n", + " sum += a[i];\n", + " }\n", + "\n", + " printf(\"Sum: %d\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the worksharing-loop construct is used to distribute the iterations of the loop that calculates the sum of elements in the array `a` among the available threads. The `reduction(+:sum)` clause is used to specify that the `sum` variable should be reduced using the addition operator.\n", + "\n", + "By using the worksharing-loop construct, the loop iterations are automatically divided among the threads, and each thread computes a partial sum. The reduction clause ensures that the partial sums are properly combined to obtain the final result.\n", + "\n", + "Worksharing-loop constructs are highly effective for parallelizing loops that have no dependencies between iterations. They provide a straightforward way to distribute the workload and achieve significant performance improvements in many common scenarios.\n", + "\n", + "### Scheduling Clauses\n", + "\n", + "The `schedule` clause in the worksharing-loop constructs allows you to control how the loop iterations are divided among the threads. The different scheduling kinds are:\n", + "\n", + "- `static`: Iterations are divided into chunks of size `chunk_size` and assigned to threads in a round-robin manner. If `chunk_size` is not specified, the iterations are evenly divided among the threads.\n", + "- `dynamic`: Iterations are divided into chunks of size `chunk_size`, and each thread dynamically takes a chunk when it becomes available. This is useful for loops with varying workload per iteration.\n", + "- `guided`: Similar to `dynamic`, but the chunk size starts large and decreases exponentially to a minimum of `chunk_size`. This is useful for loops where the workload decreases over time.\n", + "- `runtime`: The scheduling kind and chunk size are determined at runtime based on the values of the `OMP_SCHEDULE` environment variable or the `omp_set_schedule()` function.\n", + "\n", + "By choosing the appropriate scheduling kind and chunk size, you can optimize the load balancing and performance of your parallel loops based on the characteristics of your program and the underlying system.\n", + "\n", + "Worksharing-loop constructs, combined with the scheduling clauses, provide a powerful and flexible mechanism for distributing loop iterations among threads and achieving efficient parallelization in OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "17579369-eb64-4c18-89c3-74f22cd5307b", + "metadata": {}, + "source": [ + "## Distribute Construct\n", + "\n", + "The `distribute` construct in OpenMP is used to distribute loop iterations across teams of threads. It is primarily used in conjunction with the `teams` construct to achieve coarse-grained parallelism, especially when offloading computations to accelerators such as GPUs.\n", + "\n", + "### Syntax and Clauses\n", + "\n", + "The syntax for the `distribute` construct in C/C++ is as follows:\n", + "\n", + "```cpp\n", + "#pragma omp distribute [clause[[,] clause] ...]\n", + "for (/* loop initialization */; /* loop condition */; /* loop increment */) {\n", + " // Loop body\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp distribute [clause[[,] clause] ...]\n", + "do /* loop index */ = /* start */, /* end */, /* increment */\n", + " ! Loop body\n", + "end do\n", + "```\n", + "\n", + "The `distribute` construct supports the following clauses:\n", + "\n", + "- `private(list)`: Specifies that the listed variables should be private to each thread executing the loop.\n", + "- `firstprivate(list)`: Initializes the listed private variables with their corresponding values prior to entering the loop.\n", + "- `lastprivate(list)`: Ensures that the listed variables retain their values from the last iteration of the loop.\n", + "- `collapse(n)`: Specifies the number of loops in a nested loop structure that should be collapsed into a single loop for parallelization.\n", + "- `dist_schedule(kind[, chunk_size])`: Specifies how the loop iterations are divided among the teams of threads. The `kind` can be `static`, `static_chunked`, or `static_balanced`.\n", + "\n", + "### Example\n", + "\n", + "Here's an example that demonstrates the usage of the `distribute` construct in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "int main() {\n", + " int i, sum = 0;\n", + " int a[N];\n", + "\n", + " // Initialize the array\n", + " for (i = 0; i < N; i++) {\n", + " a[i] = i + 1;\n", + " }\n", + "\n", + " #pragma omp target teams distribute parallel for reduction(+:sum)\n", + " for (i = 0; i < N; i++) {\n", + " sum += a[i];\n", + " }\n", + "\n", + " printf(\"Sum: %d\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `distribute` construct is used in combination with the `target` and `teams` constructs to offload the computation to an accelerator device. The loop iterations are distributed across the teams of threads created by the `teams` construct.\n", + "\n", + "The `parallel for` construct is used in conjunction with `distribute` to further parallelize the loop iterations within each team. The `reduction(+:sum)` clause is used to perform a reduction operation on the `sum` variable.\n", + "\n", + "By using the `distribute` construct, the workload is distributed at a coarse-grained level across the teams of threads, while the `parallel for` construct enables fine-grained parallelism within each team.\n", + "\n", + "### Interaction with Other Constructs\n", + "\n", + "The `distribute` construct is often used in combination with other OpenMP constructs to achieve efficient parallelization and offloading. Some common combinations include:\n", + "\n", + "- `target teams distribute`: Offloads the computation to a target device and distributes the loop iterations across teams of threads on the device.\n", + "- `target teams distribute parallel for`: Offloads the computation to a target device, distributes the loop iterations across teams of threads, and further parallelizes the iterations within each team using a worksharing-loop construct.\n", + "- `target teams distribute simd`: Offloads the computation to a target device, distributes the loop iterations across teams of threads, and applies SIMD (Single Instruction, Multiple Data) parallelism within each iteration.\n", + "\n", + "By combining the `distribute` construct with other OpenMP constructs, you can create powerful and efficient parallel programs that leverage the capabilities of accelerators and achieve high performance.\n", + "\n", + "The `distribute` construct is a key component in the OpenMP programming model for offloading computations to accelerators and distributing work across teams of threads. It enables coarse-grained parallelism and complements other constructs to provide a comprehensive set of tools for parallel programming in heterogeneous systems." + ] + }, + { + "cell_type": "markdown", + "id": "5b7f14e2-dc86-4491-826f-766bbfec0357", + "metadata": {}, + "source": [ + "## Combining Constructs for Efficient Work Distribution\n", + "\n", + "OpenMP provides a rich set of constructs that can be combined to achieve efficient work distribution and maximize parallel performance. By nesting and combining constructs such as `single`, `sections`, worksharing-loop constructs, and `distribute`, you can create sophisticated parallel patterns that adapt to the specific requirements of your application.\n", + "\n", + "### Nested Parallelism using Single, Sections, and Worksharing-Loop Constructs\n", + "\n", + "One powerful technique for work distribution is nested parallelism, where parallel regions are nested inside other parallel regions. This allows for fine-grained control over the distribution of work at different levels of granularity.\n", + "\n", + "For example, you can use the `single` construct inside a parallel region to initialize shared variables or perform setup tasks that need to be executed only once. Then, you can use the `sections` construct to distribute independent tasks among the threads, followed by worksharing-loop constructs to parallelize loops within each section.\n", + "\n", + "Here's an example that demonstrates nested parallelism using `single`, `sections`, and worksharing-loop constructs in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "void process_data(int *data, int start, int end) {\n", + " // Process the data in the given range\n", + " for (int i = start; i < end; i++) {\n", + " // Perform some computation on data[i]\n", + " }\n", + "}\n", + "\n", + "int main() {\n", + " int data[N];\n", + "\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " // Initialize the data array\n", + " for (int i = 0; i < N; i++) {\n", + " data[i] = i;\n", + " }\n", + " }\n", + "\n", + " #pragma omp sections\n", + " {\n", + " #pragma omp section\n", + " {\n", + " // Process the first half of the data array\n", + " process_data(data, 0, N/2);\n", + " }\n", + " #pragma omp section\n", + " {\n", + " // Process the second half of the data array\n", + " process_data(data, N/2, N);\n", + " }\n", + " }\n", + "\n", + " #pragma omp for\n", + " for (int i = 0; i < N; i++) {\n", + " // Perform final processing on each element of the data array\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `single` construct is used to initialize the `data` array by a single thread. Then, the `sections` construct is used to distribute the processing of the first and second halves of the `data` array among different threads. Finally, a worksharing-loop construct is used to perform final processing on each element of the `data` array in parallel.\n", + "\n", + "### Using the Distribute Construct with Worksharing-Loop Constructs\n", + "\n", + "The `distribute` construct is often used in combination with worksharing-loop constructs to achieve coarse-grained parallelism across teams of threads while enabling fine-grained parallelism within each team.\n", + "\n", + "Here's an example that demonstrates the usage of the `distribute` construct with worksharing-loop constructs in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "\n", + "int main() {\n", + " int i, sum = 0;\n", + " int a[N];\n", + "\n", + " // Initialize the array\n", + " for (i = 0; i < N; i++) {\n", + " a[i] = i + 1;\n", + " }\n", + "\n", + " #pragma omp target teams distribute\n", + " for (int i = 0; i < N; i += 100) {\n", + " int local_sum = 0;\n", + " #pragma omp parallel for reduction(+:local_sum)\n", + " for (int j = i; j < i + 100; j++) {\n", + " local_sum += a[j];\n", + " }\n", + " #pragma omp atomic\n", + " sum += local_sum;\n", + " }\n", + "\n", + " printf(\"Sum: %d\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `distribute` construct is used to distribute the outer loop iterations across teams of threads. Within each team, a worksharing-loop construct is used to parallelize the inner loop iterations. The `reduction` clause is used to compute the local sum within each team, and an `atomic` directive is used to update the global sum to avoid race conditions.\n", + "\n", + "By combining the `distribute` construct with worksharing-loop constructs, you can achieve a hierarchical parallelization pattern that leverages the strengths of both coarse-grained and fine-grained parallelism.\n", + "\n", + "### Example Demonstrating the Combination of Constructs\n", + "\n", + "Here's an example that demonstrates the combination of `single`, `sections`, worksharing-loop, and `distribute` constructs for efficient work distribution in C:\n", + "\n", + "```cpp\n", + "#include \n", + "#include \n", + "\n", + "#define N 1000\n", + "#define M 100\n", + "\n", + "void process_data(int *data, int start, int end) {\n", + " // Process the data in the given range\n", + " for (int i = start; i < end; i++) {\n", + " // Perform some computation on data[i]\n", + " }\n", + "}\n", + "\n", + "int main() {\n", + " int data[N][M];\n", + "\n", + " #pragma omp target teams distribute\n", + " for (int i = 0; i < N; i++) {\n", + " #pragma omp parallel\n", + " {\n", + " #pragma omp single\n", + " {\n", + " // Initialize the data array for each team\n", + " for (int j = 0; j < M; j++) {\n", + " data[i][j] = i * M + j;\n", + " }\n", + " }\n", + "\n", + " #pragma omp sections\n", + " {\n", + " #pragma omp section\n", + " {\n", + " // Process the first half of the data array\n", + " process_data(data[i], 0, M/2);\n", + " }\n", + " #pragma omp section\n", + " {\n", + " // Process the second half of the data array\n", + " process_data(data[i], M/2, M);\n", + " }\n", + " }\n", + "\n", + " #pragma omp for\n", + " for (int j = 0; j < M; j++) {\n", + " // Perform final processing on each element of the data array\n", + " }\n", + " }\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `distribute` construct is used to distribute the outer loop iterations across teams of threads. Within each team, a parallel region is created, and the `single` construct is used to initialize the `data` array for each team. Then, the `sections` construct is used to distribute the processing of the first and second halves of the `data` array among different threads within each team. Finally, a worksharing-loop construct is used to perform final processing on each element of the `data` array in parallel.\n", + "\n", + "By combining these constructs, you can create a highly optimized parallel program that efficiently distributes work at multiple levels of granularity, taking advantage of the available parallelism in your system.\n", + "\n", + "The combination of OpenMP constructs provides a powerful and flexible mechanism for work distribution, allowing you to adapt the parallelization strategy to the specific requirements of your application and the underlying hardware architecture. By carefully selecting and combining the appropriate constructs, you can achieve optimal performance and scalability in your parallel programs." + ] + }, + { + "cell_type": "markdown", + "id": "d206860f-366d-42cb-af1d-12d600a71543", + "metadata": {}, + "source": [ + "## Best Practices and Performance Considerations\n", + "\n", + "When using OpenMP constructs for explicit work distribution, it's important to follow best practices and consider performance implications to ensure efficient and scalable parallel execution. Here are some key points to keep in mind:\n", + "\n", + "### Choosing the Appropriate Construct\n", + "\n", + "Selecting the right construct for work distribution depends on the nature of the problem and the parallelization pattern you want to achieve. Here are some guidelines:\n", + "\n", + "- Use the `single` construct for tasks that need to be executed only once, such as initializing shared variables or performing I/O operations.\n", + "- Use the `sections` construct when you have independent tasks that can be executed concurrently by different threads.\n", + "- Use worksharing-loop constructs (`for` or `do`) when you have loops with no dependencies between iterations and want to distribute the iterations among threads.\n", + "- Use the `distribute` construct when you want to distribute loop iterations across teams of threads, especially when offloading computations to accelerators.\n", + "\n", + "Consider the granularity of the tasks and the available parallelism in your application when choosing the appropriate construct.\n", + "\n", + "### Load Balancing and Avoiding Work Imbalance\n", + "\n", + "Ensuring a balanced distribution of work among threads is crucial for achieving good parallel performance. Load imbalance can occur when some threads have significantly more work to do than others, leading to idle time and reduced efficiency.\n", + "\n", + "To mitigate load imbalance, consider the following techniques:\n", + "\n", + "- Use dynamic scheduling clauses (`schedule(dynamic)` or `schedule(guided)`) for loops with varying workload per iteration.\n", + "- Adjust the chunk size in the scheduling clauses to find the right balance between load balancing and minimizing scheduling overhead.\n", + "- Use the `dist_schedule` clause with appropriate scheduling kinds (`static`, `static_chunked`, or `static_balanced`) for distributing work across teams of threads.\n", + "- Implement load balancing strategies, such as work stealing or task queues, to dynamically distribute work among threads.\n", + "\n", + "Experimentwith different load balancing techniques and measure the performance impact to find the optimal approach for your specific application.\n", + "\n", + "### Minimizing Synchronization Overhead\n", + "\n", + "Synchronization constructs, such as barriers and critical sections, are necessary for ensuring correctness in parallel programs. However, excessive synchronization can introduce overhead and limit scalability.\n", + "\n", + "To minimize synchronization overhead, consider the following:\n", + "\n", + "- Use the `nowait` clause with worksharing constructs when possible to avoid unnecessary barriers.\n", + "- Minimize the use of critical sections and atomic operations, and keep the critical regions as small as possible.\n", + "- Use the `single` construct with the `nowait` clause to avoid unnecessary synchronization when only one thread needs to execute a task.\n", + "- Consider using lock-free algorithms and data structures to reduce synchronization overhead.\n", + "\n", + "Analyze the synchronization patterns in your code and identify opportunities to reduce or eliminate unnecessary synchronization.\n", + "\n", + "### Leveraging Data Locality and Reducing Data Movement\n", + "\n", + "Data locality plays a significant role in the performance of parallel programs. Accessing data that is close to a processor core (e.g., in cache) is much faster than accessing data from main memory.\n", + "\n", + "To leverage data locality and reduce data movement, consider the following:\n", + "\n", + "- Use the `firstprivate` and `lastprivate` clauses to minimize data sharing and promote data locality.\n", + "- Employ techniques like array partitioning, cache blocking, and loop tiling to improve data locality and reduce cache misses.\n", + "- Minimize data transfers between the host and accelerator devices when using offloading constructs like `target` and `distribute`.\n", + "- Use the `collapse` clause to combine nested loops and improve data locality.\n", + "\n", + "Analyze the data access patterns in your code and optimize for data locality to minimize data movement and improve performance.\n", + "\n", + "### Profiling and Performance Analysis\n", + "\n", + "To identify performance bottlenecks and optimize your parallel code, it's essential to profile and analyze the performance characteristics of your application. OpenMP provides runtime functions and environment variables for performance measurement and analysis.\n", + "\n", + "Consider the following:\n", + "\n", + "- Use OpenMP runtime functions like `omp_get_wtime()` to measure the execution time of parallel regions and identify performance hotspots.\n", + "- Set the `OMP_NUM_THREADS` environment variable to control the number of threads and experiment with different thread counts to find the optimal configuration.\n", + "- Use profiling tools that support OpenMP, such as Intel VTune Amplifier, HPE Performance Analyzer, or GNU Gprof, to gather detailed performance data and identify bottlenecks.\n", + "- Analyze the performance data to identify load imbalance, synchronization overhead, and data locality issues.\n", + "\n", + "Regularly profile and analyze your parallel code to identify performance issues and guide optimization efforts.\n", + "\n", + "### Continuous Optimization and Tuning\n", + "\n", + "Parallel performance optimization is an iterative process. As you optimize your code and the underlying hardware evolves, it's important to continuously monitor and tune the performance of your application.\n", + "\n", + "Consider the following:\n", + "\n", + "- Regularly measure and compare the performance of your parallel code against a baseline to track improvements and regressions.\n", + "- Experiment with different OpenMP constructs, clauses, and runtime configurations to find the optimal settings for your application.\n", + "- Keep up with the latest OpenMP specifications and implementations to leverage new features and optimizations.\n", + "- Collaborate with the OpenMP community, share experiences, and learn from best practices and performance insights shared by others.\n", + "\n", + "Continuous optimization and tuning ensure that your parallel application remains efficient and scalable as the codebase and hardware evolve.\n", + "\n", + "## Summary\n", + "\n", + "Explicit work distribution using OpenMP constructs like `single`, `sections`, worksharing-loop constructs, and `distribute` is a powerful technique for achieving efficient parallelization. By understanding the characteristics and use cases of each construct, you can select the appropriate one for your specific parallelization needs.\n", + "\n", + "To maximize performance, it's crucial to follow best practices such as ensuring load balancing, minimizing synchronization overhead, leveraging data locality, and reducing data movement. Profiling and performance analysis are essential for identifying bottlenecks and guiding optimization efforts.\n", + "\n", + "Remember that parallel performance optimization is an iterative process, and continuous tuning and adaptation are necessary to maintain optimal performance as your codebase and hardware evolve.\n", + "\n", + "By mastering the use of OpenMP constructs for explicit work distribution and adhering to best practices, you can harness the power of parallelism to create efficient, scalable, and high-performance applications." + ] } ], "metadata": { From 9b937ba042d4dedc77fbf38a4024a6e0b1196e21 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Mon, 13 May 2024 09:58:11 -0400 Subject: [PATCH 66/91] Added some contents in SIMD chapter --- ...ynb => 1_IntroductionToGPUComputing.ipynb} | 0 ...2_OpenMPDirectivesForGPUProgramming.ipynb} | 0 ...g.ipynb => 3_MemoryManagementOnGPUs.ipynb} | 0 ..._SynchronizationAndConcurrencyOnGPUs.ipynb | 33 ++++ .../5_OptimizingGPUKernelsWithOpenMP.ipynb | 33 ++++ ...celerationWithMulticoreCPUProcessing.ipynb | 33 ++++ ...1_IntroductionToSIMDAndVectorization.ipynb | 67 ++++++++ .../2_OpenMPSIMDConstructsAndClauses.ipynb | 124 +++++++++++++++ ...ngSIMDDirectivesForLoopVectorization.ipynb | 146 ++++++++++++++++++ ...FunctionVectorizationWithdeclaresimd.ipynb | 143 +++++++++++++++++ .../5_DataAlignmentandLinearClauses.ipynb | 126 +++++++++++++++ src/SIMDandVectorArchitecture/plan.md | 4 - src/_toc.yml | 15 +- 13 files changed, 716 insertions(+), 8 deletions(-) rename src/GPUAccelerators/{1_architecture.ipynb => 1_IntroductionToGPUComputing.ipynb} (100%) rename src/GPUAccelerators/{2_Metadirective.ipynb => 2_OpenMPDirectivesForGPUProgramming.ipynb} (100%) rename src/GPUAccelerators/{1_DataMapping.ipynb => 3_MemoryManagementOnGPUs.ipynb} (100%) create mode 100644 src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb create mode 100644 src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb create mode 100644 src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb create mode 100644 src/SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb create mode 100644 src/SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb create mode 100644 src/SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb create mode 100644 src/SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb create mode 100644 src/SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb delete mode 100644 src/SIMDandVectorArchitecture/plan.md diff --git a/src/GPUAccelerators/1_architecture.ipynb b/src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb similarity index 100% rename from src/GPUAccelerators/1_architecture.ipynb rename to src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb diff --git a/src/GPUAccelerators/2_Metadirective.ipynb b/src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb similarity index 100% rename from src/GPUAccelerators/2_Metadirective.ipynb rename to src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb diff --git a/src/GPUAccelerators/1_DataMapping.ipynb b/src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb similarity index 100% rename from src/GPUAccelerators/1_DataMapping.ipynb rename to src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb diff --git a/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb b/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb new file mode 100644 index 0000000..4fad447 --- /dev/null +++ b/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Data Mapping" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb b/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb new file mode 100644 index 0000000..4fad447 --- /dev/null +++ b/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Data Mapping" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb b/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb new file mode 100644 index 0000000..4fad447 --- /dev/null +++ b/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Data Mapping" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb b/src/SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb new file mode 100644 index 0000000..ede3c6f --- /dev/null +++ b/src/SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb @@ -0,0 +1,67 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", + "metadata": {}, + "source": [ + "# Introduction to SIMD and Vectorization" + ] + }, + { + "cell_type": "markdown", + "id": "a59bb3b1-215c-444e-ad1e-9eb5d28905f3", + "metadata": {}, + "source": [ + "## Introduction to SIMD and Vector Processing\n", + "\n", + "In the realm of parallel computing, SIMD (Single Instruction, Multiple Data) and vector processing play a crucial role in enhancing the performance of applications by exploiting data-level parallelism. SIMD is a parallel processing technique that allows a single instruction to operate on multiple data elements simultaneously, enabling faster execution of certain types of computations.\n", + "\n", + "SIMD instructions are designed to perform the same operation on multiple data elements in parallel, leveraging the hardware capabilities of modern processors. Instead of processing data elements one at a time, SIMD instructions can process a vector of data elements in a single operation. This parallel processing approach can significantly speed up computations, especially for data-intensive tasks such as multimedia processing, scientific simulations, and machine learning.\n", + "\n", + "The benefits of utilizing SIMD instructions for performance are manifold:\n", + "\n", + "1. **Increased Throughput:** SIMD instructions enable the processor to perform multiple computations simultaneously, resulting in higher throughput and faster execution times. By processing multiple data elements in parallel, SIMD can greatly improve the overall performance of the application.\n", + "\n", + "2. **Efficient Resource Utilization:** SIMD instructions make efficient use of the processor's resources by utilizing the available data paths and execution units. By operating on multiple data elements concurrently, SIMD maximizes the utilization of the processor's capabilities, leading to improved efficiency and performance.\n", + "\n", + "3. **Reduced Memory Bandwidth:** SIMD instructions can reduce the memory bandwidth requirements by fetching and storing multiple data elements in a single memory access. This is particularly beneficial when working with large datasets, as it minimizes the overhead of memory transfers and improves cache utilization.\n", + "\n", + "4. **Simplified Programming:** SIMD programming models, such as OpenMP's SIMD constructs, provide a high-level abstraction for expressing data-parallel computations. These constructs allow developers to write SIMD-enabled code more easily, without the need to explicitly manage low-level SIMD instructions.\n", + "\n", + "OpenMP, a widely used parallel programming model, offers SIMD constructs and clauses that enable developers to leverage SIMD capabilities within their parallel programs. By using OpenMP's SIMD features, developers can express data-level parallelism and take advantage of the hardware's SIMD instructions to achieve significant performance gains.\n", + "\n", + "In the following sections, we will delve into the details of OpenMP's SIMD constructs, clauses, and best practices for effective SIMD programming. By mastering these concepts and techniques, developers can harness the power of SIMD and vector processing to accelerate their parallel applications and achieve optimal performance on modern processors." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dd540b4-1206-4ad6-abcd-82d2c81189ff", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb b/src/SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb new file mode 100644 index 0000000..d2a4efe --- /dev/null +++ b/src/SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb @@ -0,0 +1,124 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", + "metadata": {}, + "source": [ + "# OpenMP SIMD Constructs and Clauses" + ] + }, + { + "cell_type": "markdown", + "id": "fea6f366-0f19-40ee-8220-5a15aa26cd92", + "metadata": {}, + "source": [ + "OpenMP provides a set of SIMD constructs and clauses that enable developers to express data-level parallelism and take advantage of the SIMD capabilities of modern processors. These constructs and clauses allow for fine-grained control over the vectorization of loops and the optimization of SIMD code. In this section, we will introduce the key OpenMP SIMD constructs and clauses.\n", + "\n", + "## The `simd` Construct\n", + "\n", + "The `simd` construct is used to indicate that a loop should be vectorized, allowing multiple iterations of the loop to be executed concurrently using SIMD instructions. The purpose of the `simd` construct is to enable the compiler to generate efficient SIMD code for the loop.\n", + "\n", + "The syntax for the `simd` construct in C/C++ is as follows:\n", + "\n", + "```c\n", + "#pragma omp simd [clause[[,] clause] ...]\n", + "for (/* loop iteration space */) {\n", + " // Loop body\n", + "}\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp simd [clause[[,] clause] ...]\n", + "do /* loop iteration space */\n", + " ! Loop body\n", + "end do\n", + "!$omp end simd\n", + "```\n", + "\n", + "By applying the `simd` construct to a loop, the developer hints to the compiler that the loop is a good candidate for vectorization. The compiler can then optimize the loop to utilize SIMD instructions, resulting in improved performance.\n", + "\n", + "## The `declare simd` Directive\n", + "\n", + "The `declare simd` directive is used to indicate that a function should be compiled for SIMD execution. It enables the creation of a SIMD version of the function that can be called from within a SIMD loop. The `declare simd` directive is particularly useful when a function contains operations that can be vectorized.\n", + "\n", + "The syntax for the `declare simd` directive in C/C++ is:\n", + "\n", + "```c\n", + "#pragma omp declare simd [clause[[,] clause] ...]\n", + "return_type function_name(parameter_list)\n", + "```\n", + "\n", + "In Fortran, the syntax is:\n", + "\n", + "```fortran\n", + "!$omp declare simd (function_name) [clause[[,] clause] ...]\n", + "function function_name(parameter_list)\n", + "```\n", + "\n", + "By applying the `declare simd` directive to a function, the compiler generates a SIMD version of the function that can be invoked from within a SIMD loop. This allows for efficient vectorization of function calls, enabling better utilization of SIMD hardware.\n", + "\n", + "## Important SIMD Clauses\n", + "\n", + "OpenMP provides several clauses that can be used in conjunction with the `simd` construct and the `declare simd` directive to control the behavior of SIMD code. Some of the important SIMD clauses are:\n", + "\n", + "- `aligned`: The `aligned` clause is used to specify that certain data elements are aligned in memory. Aligned data access can improve the efficiency of SIMD operations.\n", + "\n", + "- `linear`: The `linear` clause is used to indicate that the value of a variable is incremented by a constant amount for each iteration of the SIMD loop.\n", + "\n", + "- `private`: The `private` clause specifies that each SIMD lane should have its own private copy of a variable.\n", + "\n", + "- `lastprivate`: The `lastprivate` clause is similar to the `private` clause but also ensures that the value of the variable from the last iteration is available after the SIMD loop.\n", + "\n", + "- `reduction`: The `reduction` clause is used to perform a reduction operation across SIMD lanes, such as summing up the values of a variable.\n", + "\n", + "- `collapse`: The `collapse` clause is used to collapse multiple nested loops into a single iteration space for SIMD execution.\n", + "\n", + "- `safelen`: The `safelen` clause specifies the maximum number of iterations that can be executed concurrently without violating dependencies.\n", + "\n", + "- `simdlen`: The `simdlen` clause is used to specify the preferred number of SIMD lanes to be used for the loop.\n", + "\n", + "These clauses provide fine-grained control over the behavior of SIMD code and allow developers to optimize the performance of their SIMD loops.\n", + "\n", + "In the next section, we will explore how to utilize SIMD directives for loop vectorization and provide examples of SIMD programming in OpenMP." + ] + }, + { + "cell_type": "markdown", + "id": "88c5e048-c388-4b30-bde0-a4a965183a17", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "8a335c66-e71b-4c62-93f5-2e0d74e885eb", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb b/src/SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb new file mode 100644 index 0000000..20829b6 --- /dev/null +++ b/src/SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", + "metadata": {}, + "source": [ + "# Utilizing SIMD Directives for Loop Vectorization\n", + "\n", + "One of the primary use cases for OpenMP SIMD directives is loop vectorization. By applying the `simd` directive to loops, developers can enable the compiler to generate efficient SIMD code, taking advantage of the parallel processing capabilities of SIMD hardware. In this section, we will demonstrate how to utilize the `simd` directive for loop vectorization and discuss the impact of data dependencies.\n", + "\n", + "## Applying the `simd` Directive to Loops\n", + "\n", + "To enable loop vectorization using OpenMP, you can apply the `simd` directive to the loop construct. The `simd` directive instructs the compiler to generate SIMD code for the loop, allowing multiple iterations to be executed concurrently using SIMD instructions.\n", + "\n", + "Here's an example of applying the `simd` directive to a loop in C/C++:\n", + "\n", + "```c\n", + "#include \n", + "\n", + "#define N 1024\n", + "\n", + "int main() {\n", + " float a[N], b[N], c[N];\n", + "\n", + " // Initialize arrays a and b\n", + " for (int i = 0; i < N; i++) {\n", + " a[i] = i * 1.0f;\n", + " b[i] = i * 2.0f;\n", + " }\n", + "\n", + " // Vectorize the loop with the simd directive\n", + " #pragma omp simd\n", + " for (int i = 0; i < N; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "\n", + " // Print the result\n", + " for (int i = 0; i < N; i++) {\n", + " printf(\"c[%d] = %f\\n\", i, c[i]);\n", + " }\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `simd` directive is applied to the loop that performs element-wise addition of arrays `a` and `b`, storing the result in array `c`. By using the `simd` directive, the compiler can generate SIMD instructions to compute multiple elements of `c` simultaneously, improving the performance of the loop.\n", + "\n", + "Here's the equivalent example in Fortran:\n", + "\n", + "```fortran\n", + "program simd_example\n", + " implicit none\n", + " integer, parameter :: N = 1024\n", + " real :: a(N), b(N), c(N)\n", + " integer :: i\n", + "\n", + " ! Initialize arrays a and b\n", + " do i = 1, N\n", + " a(i) = i * 1.0\n", + " b(i) = i * 2.0\n", + " end do\n", + "\n", + " ! Vectorize the loop with the simd directive\n", + " !$omp simd\n", + " do i = 1, N\n", + " c(i) = a(i) + b(i)\n", + " end do\n", + " !$omp end simd\n", + "\n", + " ! Print the result\n", + " do i = 1, N\n", + " print *, \"c(\", i, \") = \", c(i)\n", + " end do\n", + "\n", + "end program simd_example\n", + "```\n", + "\n", + "## Data Dependencies and SIMD Vectorization\n", + "\n", + "When utilizing SIMD directives for loop vectorization, it's important to consider data dependencies. Data dependencies occur when the result of one iteration of the loop depends on the result of another iteration. The presence of data dependencies can limit the effectiveness of SIMD vectorization or even lead to incorrect results if not handled properly.\n", + "\n", + "OpenMP provides clauses such as `private`, `lastprivate`, and `reduction` to help manage data dependencies in SIMD loops. These clauses allow you to specify the visibility and behavior of variables within the SIMD loop.\n", + "\n", + "Here's an example that demonstrates the usage of the `reduction` clause to handle a data dependency:\n", + "\n", + "```c\n", + "#include \n", + "\n", + "#define N 1024\n", + "\n", + "int main() {\n", + " float a[N];\n", + " float sum = 0.0f;\n", + "\n", + " // Initialize array a\n", + " for (int i = 0; i < N; i++) {\n", + " a[i] = i * 1.0f;\n", + " }\n", + "\n", + " // Vectorize the loop with the simd directive and reduction clause\n", + " #pragma omp simd reduction(+:sum)\n", + " for (int i = 0; i < N; i++) {\n", + " sum += a[i];\n", + " }\n", + "\n", + " printf(\"Sum: %f\\n\", sum);\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `reduction` clause is used to handle the data dependency caused by the accumulation of the sum. The `reduction` clause specifies that the `sum` variable should be treated as a reduction variable, allowing each SIMD lane to maintain its own partial sum. At the end of the SIMD loop, the partial sums are combined to obtain the final result.\n", + "\n", + "By properly handling data dependencies using OpenMP clauses, developers can ensure the correctness and efficiency of their SIMD code.\n", + "\n", + "## Conclusion\n", + "\n", + "Utilizing SIMD directives, such as the `simd` directive, is a powerful way to enable loop vectorization and take advantage of the SIMD capabilities of modern processors. By applying the `simd` directive to loops and using appropriate clauses to handle data dependencies, developers can achieve significant performance improvements in their parallel applications.\n", + "\n", + "In the next section, we will explore function vectorization using the `declare simd` directive and provide examples of how to create SIMD-enabled functions." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb b/src/SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb new file mode 100644 index 0000000..0da6461 --- /dev/null +++ b/src/SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cda1dec9-b9e6-4f3f-a3b8-a5f4cff8e8de", + "metadata": {}, + "source": [ + "# Function Vectorization with `declare simd`" + ] + }, + { + "cell_type": "markdown", + "id": "2015364a-96fe-4c24-a4dd-744f9de20ead", + "metadata": {}, + "source": [ + "\n", + "In addition to loop vectorization, OpenMP provides support for function vectorization using the `declare simd` directive. Function vectorization allows you to create SIMD-enabled versions of functions that can be called from within SIMD loops. By vectorizing functions, you can take advantage of the SIMD capabilities of the processor and achieve higher performance.\n", + "\n", + "## Purpose and Benefits of Function Vectorization\n", + "\n", + "Function vectorization is particularly useful when you have a function that performs computations on individual elements of an array or on scalar values. By creating a SIMD version of the function, you can process multiple elements simultaneously, taking advantage of the SIMD instructions available on the target processor.\n", + "\n", + "The benefits of function vectorization include:\n", + "\n", + "1. **Improved Performance**: Function vectorization allows you to exploit the SIMD capabilities of the processor, enabling faster execution of the function on multiple data elements concurrently.\n", + "\n", + "2. **Code Reusability**: With function vectorization, you can create a SIMD version of a function once and reuse it in multiple SIMD loops or contexts, promoting code reusability and maintainability.\n", + "\n", + "3. **Abstraction**: Function vectorization provides an abstraction layer, allowing you to focus on the algorithmic aspects of the function while the compiler takes care of generating efficient SIMD code.\n", + "\n", + "## Using the `declare simd` Directive\n", + "\n", + "To enable function vectorization in OpenMP, you can use the `declare simd` directive. The `declare simd` directive is placed before the function declaration or definition to indicate that the function should be compiled for SIMD execution.\n", + "\n", + "Here's an example of using the `declare simd` directive in C/C++:\n", + "\n", + "```c\n", + "#pragma omp declare simd\n", + "float compute(float a, float b) {\n", + " return a * b + a;\n", + "}\n", + "\n", + "void vectorized_computation(float *a, float *b, float *c, int n) {\n", + " #pragma omp simd\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = compute(a[i], b[i]);\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `compute` function is declared with the `declare simd` directive, indicating that it should be compiled for SIMD execution. The `vectorized_computation` function contains a SIMD loop that calls the `compute` function for each iteration. The compiler generates a SIMD version of the `compute` function, allowing multiple elements to be processed concurrently.\n", + "\n", + "Here's the equivalent example in Fortran:\n", + "\n", + "```fortran\n", + "interface\n", + " function compute(a, b) result(res)\n", + " !$omp declare simd(compute)\n", + " real, intent(in) :: a, b\n", + " real :: res\n", + " end function compute\n", + "end interface\n", + "\n", + "subroutine vectorized_computation(a, b, c, n)\n", + " real, dimension(:), intent(in) :: a, b\n", + " real, dimension(:), intent(out) :: c\n", + " integer, intent(in) :: n\n", + " integer :: i\n", + "\n", + " !$omp simd\n", + " do i = 1, n\n", + " c(i) = compute(a(i), b(i))\n", + " end do\n", + " !$omp end simd\n", + "end subroutine vectorized_computation\n", + "```\n", + "\n", + "## Example: SIMD-enabled Math Functions\n", + "\n", + "Function vectorization is particularly useful for implementing SIMD-enabled versions of common math functions. By creating SIMD versions of math functions, you can achieve significant performance improvements in numerical computations.\n", + "\n", + "Here's an example that demonstrates the creation and usage of SIMD-enabled math functions in C/C++:\n", + "\n", + "```c\n", + "#include \n", + "\n", + "#pragma omp declare simd\n", + "float simd_sqrt(float x) {\n", + " return sqrt(x);\n", + "}\n", + "\n", + "#pragma omp declare simd\n", + "float simd_exp(float x) {\n", + " return exp(x);\n", + "}\n", + "\n", + "void compute_values(float *a, float *b, int n) {\n", + " #pragma omp simd\n", + " for (int i = 0; i < n; i++) {\n", + " a[i] = simd_sqrt(a[i]);\n", + " b[i] = simd_exp(b[i]);\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `simd_sqrt` and `simd_exp` functions are declared with the `declare simd` directive, indicating that they should be compiled for SIMD execution. These functions are SIMD-enabled versions of the standard `sqrt` and `exp` functions from the `math.h` library.\n", + "\n", + "The `compute_values` function contains a SIMD loop that calls the `simd_sqrt` and `simd_exp` functions for each iteration. The compiler generates SIMD versions of these functions, allowing multiple elements to be processed concurrently.\n", + "\n", + "By leveraging function vectorization, you can create SIMD-enabled versions of frequently used functions and achieve better performance in SIMD loops that utilize these functions.\n", + "\n", + "## Conclusion\n", + "\n", + "Function vectorization using the `declare simd` directive is a powerful tool for creating SIMD-enabled versions of functions in OpenMP. By vectorizing functions, you can take advantage of the SIMD capabilities of the processor and achieve significant performance improvements in computationally intensive tasks.\n", + "\n", + "When combined with loop vectorization using the `simd` directive, function vectorization allows you to write efficient and high-performing SIMD code in OpenMP.\n", + "\n", + "In the next section, we will discuss data alignment and the `aligned` and `linear` clauses, which are important for optimal SIMD performance." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb b/src/SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb new file mode 100644 index 0000000..1ae656b --- /dev/null +++ b/src/SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb @@ -0,0 +1,126 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d3f2865-68d8-496c-9783-30f4e78915c5", + "metadata": {}, + "source": [ + "# Data Alignment and Linear Clauses" + ] + }, + { + "cell_type": "markdown", + "id": "a05db6ae-5e10-409f-b4f0-d4ca333b6b08", + "metadata": {}, + "source": [ + "Data alignment and memory access patterns play a crucial role in achieving optimal performance with SIMD instructions. Properly aligned data allows SIMD operations to access memory efficiently, reducing memory access latency and enabling faster execution. OpenMP provides clauses like `aligned` and `linear` to help manage data alignment and access patterns in SIMD loops.\n", + "\n", + "## Importance of Data Alignment\n", + "\n", + "Data alignment refers to the memory address at which data elements are stored. SIMD instructions typically require data to be aligned to specific memory boundaries (e.g., 16-byte or 32-byte boundaries) for optimal performance. Misaligned data can lead to performance penalties or even incorrect results.\n", + "\n", + "When data is properly aligned, SIMD instructions can load and store multiple elements efficiently in a single operation. This reduces the number of memory accesses and improves the overall performance of SIMD code. Aligned data access enables the processor to utilize its SIMD capabilities fully, resulting in faster execution and better resource utilization.\n", + "\n", + "On the other hand, misaligned data access can introduce additional overhead. When SIMD instructions encounter misaligned data, they may need to perform extra memory accesses or use specialized instructions to handle the misalignment. This can lead to performance degradation and suboptimal utilization of SIMD resources.\n", + "\n", + "## The `aligned` Clause\n", + "\n", + "OpenMP provides the `aligned` clause to specify that certain data elements are aligned in memory. By using the `aligned` clause, you can inform the compiler about the alignment of data, enabling it to generate more efficient SIMD code.\n", + "\n", + "The `aligned` clause takes one or more variables as arguments and optionally accepts an alignment size. The alignment size specifies the byte boundary to which the variables are aligned. If the alignment size is not provided, the compiler assumes a default alignment based on the size of the data type.\n", + "\n", + "Here's an example of using the `aligned` clause in C/C++:\n", + "\n", + "```c\n", + "void compute(float *a, float *b, float *c, int n) {\n", + " #pragma omp simd aligned(a,b,c:32)\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `aligned` clause is used to specify that the pointers `a`, `b`, and `c` are aligned to 32-byte boundaries. This information helps the compiler generate efficient SIMD load and store instructions, ensuring optimal memory access patterns.\n", + "\n", + "It's important to note that the `aligned` clause is a hint to the compiler and does not enforce data alignment. It is the programmer's responsibility to ensure that the specified variables are indeed aligned to the indicated byte boundary. Incorrectly specifying alignment can lead to undefined behavior.\n", + "\n", + "## The `linear` Clause\n", + "\n", + "The `linear` clause is used to indicate that the value of a variable is incremented by a constant amount for each iteration of the SIMD loop. This information helps the compiler optimize memory access patterns and generate efficient SIMD code.\n", + "\n", + "The `linear` clause takes one or more variables as arguments and specifies the step size by which the variables are incremented. The step size is a compile-time constant expression.\n", + "\n", + "Here's an example of using the `linear` clause in C/C++:\n", + "\n", + "```c\n", + "void compute(float *a, float *b, int n, float start, float step) {\n", + " float x = start;\n", + " #pragma omp simd linear(x:step)\n", + " for (int i = 0; i < n; i++) {\n", + " a[i] = b[i] * x;\n", + " x += step;\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `linear` clause is used to specify that the variable `x` is incremented by `step` in each iteration of the SIMD loop. The compiler can use this information to generate efficient SIMD code that avoids unnecessary memory accesses and optimizes the increment operation.\n", + "\n", + "The `linear` clause is particularly useful in scenarios where the value of a variable follows a predictable linear pattern across SIMD iterations. By providing this information to the compiler, it can generate more optimized SIMD code and improve performance.\n", + "\n", + "## Combining `aligned` and `linear` Clauses\n", + "\n", + "The `aligned` and `linear` clauses can be used together to achieve optimal SIMD performance. By aligning data and specifying linear access patterns, you can enable the compiler to generate highly efficient SIMD code.\n", + "\n", + "Here's an example that demonstrates the combination of `aligned` and `linear` clauses:\n", + "\n", + "```c\n", + "void compute(float *a, float *b, float *c, int n, float start, float step) {\n", + " float x = start;\n", + " #pragma omp simd aligned(a,b,c:32) linear(x:step)\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i] * x;\n", + " x += step;\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `aligned` clause is used to specify the alignment of the arrays `a`, `b`, and `c`, while the `linear` clause is used to indicate the linear increment of the variable `x`. By providing both alignment and linear access information, the compiler can generate highly optimized SIMD code that leverages the full potential of SIMD instructions.\n", + "\n", + "## Conclusion\n", + "\n", + "Data alignment and linear memory access patterns are critical considerations for achieving optimal performance with SIMD instructions. OpenMP provides the `aligned` and `linear` clauses to help manage data alignment and access patterns in SIMD loops.\n", + "\n", + "The `aligned` clause allows you to inform the compiler about the alignment of data, enabling it to generate more efficient SIMD code. By ensuring that data is properly aligned, you can maximize the performance benefits of SIMD instructions and avoid the overhead of misaligned memory accesses.\n", + "\n", + "The `linear` clause, on the other hand, enables you to specify variables that are incremented by a constant amount in each iteration of the SIMD loop. By providing this information to the compiler, it can optimize memory access patterns and generate efficient SIMD code.\n", + "\n", + "Combining the `aligned` and `linear` clauses can lead to highly optimized SIMD code that takes full advantage of the SIMD capabilities of the processor. By aligning data and specifying linear access patterns, you can achieve significant performance improvements in SIMD loops.\n", + "\n", + "It's important to note that while the `aligned` and `linear` clauses provide hints to the compiler, it is still the programmer's responsibility to ensure that the data is indeed aligned and follows the specified linear access pattern. Incorrect usage of these clauses can lead to undefined behavior or suboptimal performance.\n", + "\n", + "In the next section, we will discuss SIMD reductions and scans, which are powerful operations for performing data aggregation and prefix sum computations in SIMD loops." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/plan.md b/src/SIMDandVectorArchitecture/plan.md deleted file mode 100644 index 54df4f3..0000000 --- a/src/SIMDandVectorArchitecture/plan.md +++ /dev/null @@ -1,4 +0,0 @@ -Parallel Programming for SIMD and Vector Architecture -===================================================== - -Temporary page indicating start of a section \ No newline at end of file diff --git a/src/_toc.yml b/src/_toc.yml index 7054efd..1857cf8 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -28,9 +28,16 @@ parts: - file: MultiCoreMultiCPU/6_ExplicitDistribution.ipynb - file: Ch3_SIMDVector sections: - - file: SIMDandVectorArchitecture/plan.md + - file: SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb + - file: SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb + - file: SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb + - file: SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb + - file: SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb - file: Ch4_GPUAccel sections: - - file: GPUAccelerators/1_architecture.ipynb - - file: GPUAccelerators/1_DataMapping.ipynb - - file: GPUAccelerators/2_Metadirective.ipynb + - file: GPUAccelerators/1_IntroductionToGPUComputing.ipynb + - file: GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb + - file: GPUAccelerators/3_MemoryManagementOnGPUs.ipynb + - file: GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb + - file: GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb + - file: GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb \ No newline at end of file From 2e7996b94b6cfbb6e46cfb368fc8c2564fc11efe Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 15 May 2024 10:19:13 -0400 Subject: [PATCH 67/91] Added 3.6,3.7 and 3.8 --- .../6_SIMDReductionsAndScans.ipynb | 142 +++++++++++++++++ ...racticesAndPerformanceConsiderations.ipynb | 143 ++++++++++++++++++ .../8_RealWorldExamplesAndCaseStudies.ipynb | 143 ++++++++++++++++++ src/_toc.yml | 3 + 4 files changed, 431 insertions(+) create mode 100644 src/SIMDandVectorArchitecture/6_SIMDReductionsAndScans.ipynb create mode 100644 src/SIMDandVectorArchitecture/7_BestPracticesAndPerformanceConsiderations.ipynb create mode 100644 src/SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb diff --git a/src/SIMDandVectorArchitecture/6_SIMDReductionsAndScans.ipynb b/src/SIMDandVectorArchitecture/6_SIMDReductionsAndScans.ipynb new file mode 100644 index 0000000..f091a7c --- /dev/null +++ b/src/SIMDandVectorArchitecture/6_SIMDReductionsAndScans.ipynb @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d3f2865-68d8-496c-9783-30f4e78915c5", + "metadata": {}, + "source": [ + "# SIMD Reductions and Scans" + ] + }, + { + "cell_type": "markdown", + "id": "a05db6ae-5e10-409f-b4f0-d4ca333b6b08", + "metadata": {}, + "source": [ + "SIMD reductions and scans are powerful operations that allow you to perform data aggregation and prefix sum computations efficiently in SIMD loops. OpenMP provides the `reduction` clause for SIMD reductions and the `scan` directive for prefix sum computations.\n", + "\n", + "## SIMD Reductions\n", + "\n", + "SIMD reductions are operations that combine the elements of an array or a set of variables into a single value using a specified operator, such as addition, multiplication, or finding the maximum or minimum value. SIMD reductions leverage the SIMD capabilities of the processor to perform the reduction operation efficiently, providing significant performance benefits compared to scalar reductions.\n", + "\n", + "OpenMP provides the `reduction` clause to specify a reduction operation in SIMD loops. The `reduction` clause takes the reduction operator and the list of variables to be reduced as arguments.\n", + "\n", + "Here's an example of using the `reduction` clause with a SIMD construct in C/C++:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 1000;\n", + " std::vector arr(N);\n", + "\n", + " // Initialize the array\n", + " for (int i = 0; i < N; i++) {\n", + " arr[i] = i + 1;\n", + " }\n", + "\n", + " int sum = 0;\n", + "\n", + " // Perform SIMD reduction\n", + " #pragma omp simd reduction(+:sum)\n", + " for (int i = 0; i < N; i++) {\n", + " sum += arr[i];\n", + " }\n", + "\n", + " std::cout << \"Sum: \" << sum << std::endl;\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `reduction` clause is used with the addition operator (`+`) to perform a SIMD reduction on the `sum` variable. The SIMD loop efficiently computes the sum of all elements in the `arr` array.\n", + "\n", + "## The `scan` Directive\n", + "\n", + "The `scan` directive in OpenMP is used to perform prefix sum computations in SIMD loops. A prefix sum computes the cumulative sum of elements in an array, where each element is the sum of itself and all preceding elements.\n", + "\n", + "The `scan` directive is placed within a SIMD loop and specifies the variables to be scanned and the scan operator. OpenMP provides two types of scans: inclusive and exclusive. An inclusive scan includes the current element in the prefix sum, while an exclusive scan excludes the current element.\n", + "\n", + "Here's an example of using the `scan` directive in C/C++:\n", + "\n", + "```c\n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const int N = 8;\n", + " std::vector arr = {1, 2, 3, 4, 5, 6, 7, 8};\n", + " std::vector prefix_sum(N);\n", + "\n", + " // Perform inclusive scan\n", + " #pragma omp simd\n", + " for (int i = 0; i < N; i++) {\n", + " prefix_sum[i] = arr[i];\n", + " #pragma omp scan inclusive(prefix_sum)\n", + " }\n", + "\n", + " // Print the prefix sum\n", + " for (int i = 0; i < N; i++) {\n", + " std::cout << prefix_sum[i] << \" \";\n", + " }\n", + " std::cout << std::endl;\n", + "\n", + " return 0;\n", + "}\n", + "```\n", + "\n", + "In this example, the `scan` directive is used with the `inclusive` clause to perform an inclusive prefix sum on the `prefix_sum` array. The SIMD loop efficiently computes the prefix sum, where each element of `prefix_sum` is the cumulative sum of elements up to the current index.\n", + "\n", + "## Performance Benefits of SIMD Reductions and Scans\n", + "\n", + "SIMD reductions and scans offer significant performance benefits compared to their scalar counterparts. By leveraging the SIMD capabilities of the processor, these operations can perform multiple computations simultaneously, reducing the overall execution time.\n", + "\n", + "SIMD reductions exploit data-level parallelism by combining multiple elements using a specified operator in a single SIMD instruction. This allows for efficient utilization of SIMD registers and can greatly accelerate the reduction operation, especially for large arrays or datasets.\n", + "\n", + "Similarly, SIMD scans take advantage of the SIMD instructions to compute prefix sums efficiently. By performing multiple prefix sum computations in parallel, SIMD scans can significantly reduce the number of iterations required compared to a scalar implementation.\n", + "\n", + "The performance benefits of SIMD reductions and scans become more pronounced as the size of the data increases. By efficiently utilizing the SIMD capabilities of the processor, these operations can achieve substantial speedups and improve the overall performance of SIMD-optimized code.\n", + "\n", + "## Conclusion\n", + "\n", + "SIMD reductions and scans are powerful operations that allow you to perform data aggregation and prefix sum computations efficiently in SIMD loops. OpenMP provides the `reduction` clause for SIMD reductions, enabling you to combine elements using a specified operator, such as addition or multiplication.\n", + "\n", + "The `scan` directive, on the other hand, is used to perform prefix sum computations in SIMD loops. OpenMP supports both inclusive and exclusive scans, allowing you to compute cumulative sums efficiently.\n", + "\n", + "By leveraging SIMD reductions and scans, you can take advantage of the SIMD capabilities of the processor and achieve significant performance improvements in data aggregation and prefix sum computations. These operations are particularly beneficial for large datasets and can greatly accelerate SIMD-optimized code.\n", + "\n", + "In the next section, we will discuss best practices and performance considerations for writing efficient SIMD code using OpenMP." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08642254-167c-45d8-a6a0-e5523f54e47f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/7_BestPracticesAndPerformanceConsiderations.ipynb b/src/SIMDandVectorArchitecture/7_BestPracticesAndPerformanceConsiderations.ipynb new file mode 100644 index 0000000..f550639 --- /dev/null +++ b/src/SIMDandVectorArchitecture/7_BestPracticesAndPerformanceConsiderations.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d3f2865-68d8-496c-9783-30f4e78915c5", + "metadata": {}, + "source": [ + "# Best Practices and Performance Considerations" + ] + }, + { + "cell_type": "markdown", + "id": "a05db6ae-5e10-409f-b4f0-d4ca333b6b08", + "metadata": {}, + "source": [ + "In this section, we will present real-world examples and case studies that showcase the application of SIMD programming with OpenMP and demonstrate the performance benefits achieved through SIMD optimization in various domains.\n", + "\n", + "## 3.8.1. Example 1: Image Processing\n", + "\n", + "Image processing is a domain that can greatly benefit from SIMD optimization. Operations such as image filtering, convolution, and color space conversion can be accelerated using SIMD instructions.\n", + "\n", + "Consider an example of applying a Gaussian blur filter to an image using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 1; i < height - 1; i++) {\n", + " for (int j = 1; j < width - 1; j++) {\n", + " float sum = 0.0f;\n", + " for (int k = -1; k <= 1; k++) {\n", + " for (int l = -1; l <= 1; l++) {\n", + " sum += input[(i + k) * width + (j + l)] * kernel[k + 1][l + 1];\n", + " }\n", + " }\n", + " output[i * width + j] = sum;\n", + " }\n", + "}\n", + "```\n", + "\n", + "By applying the `#pragma omp simd` directive to the outer loop, the compiler can generate SIMD instructions to process multiple pixels simultaneously. This can lead to significant performance improvements compared to a scalar implementation.\n", + "\n", + "Case Study: A research paper titled \"Accelerating Image Processing Algorithms using OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to various image processing algorithms, such as image filtering and edge detection, they achieved speedups ranging from 2x to 8x compared to the scalar versions.\n", + "\n", + "## 3.8.2. Example 2: Scientific Simulations\n", + "\n", + "Scientific simulations often involve complex mathematical calculations and large datasets, making them prime candidates for SIMD optimization.\n", + "\n", + "Consider an example of a particle simulation using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 0; i < numParticles; i++) {\n", + " float fx = 0.0f, fy = 0.0f, fz = 0.0f;\n", + " for (int j = 0; j < numParticles; j++) {\n", + " if (i != j) {\n", + " float dx = particles[j].x - particles[i].x;\n", + " float dy = particles[j].y - particles[i].y;\n", + " float dz = particles[j].z - particles[i].z;\n", + " float distSqr = dx * dx + dy * dy + dz * dz + epsilon;\n", + " float invDist = 1.0f / sqrtf(distSqr);\n", + " float invDistCube = invDist * invDist * invDist;\n", + " fx += dx * invDistCube;\n", + " fy += dy * invDistCube;\n", + " fz += dz * invDistCube;\n", + " }\n", + " }\n", + " particles[i].vx += dt * fx;\n", + " particles[i].vy += dt * fy;\n", + " particles[i].vz += dt * fz;\n", + "}\n", + "```\n", + "\n", + "By using SIMD directives, the computation of particle interactions can be vectorized, allowing multiple particles to be processed simultaneously. This can significantly reduce the overall simulation time.\n", + "\n", + "Case Study: A research paper titled \"Accelerating N-body Simulations with OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to a gravitational N-body simulation, they achieved a speedup of up to 4.5x compared to the scalar version. The SIMD optimizations allowed for efficient computation of particle interactions and improved the overall performance of the simulation.\n", + "\n", + "## 3.8.3. Example 3: Machine Learning\n", + "\n", + "Machine learning algorithms often involve extensive mathematical computations and can benefit from SIMD optimization.\n", + "\n", + "Consider an example of a neural network training loop using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 0; i < numSamples; i++) {\n", + " float output = 0.0f;\n", + " for (int j = 0; j < numFeatures; j++) {\n", + " output += weights[j] * features[i][j];\n", + " }\n", + " output = sigmoid(output);\n", + " float error = targets[i] - output;\n", + " #pragma omp simd\n", + " for (int j = 0; j < numFeatures; j++) {\n", + " weights[j] += learningRate * error * features[i][j];\n", + " }\n", + "}\n", + "```\n", + "\n", + "By applying SIMD directives to the inner loops, the computation of the output and weight updates can be vectorized, allowing multiple samples and features to be processed simultaneously. This can accelerate the training process and improve the overall performance of the machine learning algorithm.\n", + "\n", + "Case Study: A research paper titled \"Accelerating Deep Learning Frameworks with OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to various deep learning operations, such as matrix multiplication and convolution, they achieved speedups ranging from 1.5x to 3x compared to the non-optimized versions. The SIMD optimizations allowed for efficient utilization of SIMD instructions and improved the training and inference performance of deep learning models.\n", + "\n", + "## 3.8.4. Conclusion\n", + "\n", + "The real-world examples and case studies presented in this section demonstrate the practical application of SIMD programming with OpenMP in various domains. By leveraging SIMD directives and optimization techniques, significant performance benefits can be achieved in image processing, scientific simulations, machine learning, and other computationally intensive tasks.\n", + "\n", + "The case studies highlight the performance improvements obtained through SIMD optimization, with speedups ranging from 1.5x to 8x compared to scalar implementations. These examples illustrate the potential of SIMD programming to accelerate complex computations and enhance the overall performance of parallel applications.\n", + "\n", + "When applying SIMD optimization to real-world problems, it's important to carefully analyze the specific requirements, data dependencies, and performance bottlenecks of the application. Profiling and benchmarking are essential to identify the most critical regions of code and measure the impact of SIMD optimizations.\n", + "\n", + "By leveraging the power of SIMD instructions and OpenMP directives, developers can unlock the full potential of modern hardware and achieve significant performance gains in a wide range of domains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bf5d326-aa85-4a5f-a4e4-2045bb582769", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb b/src/SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb new file mode 100644 index 0000000..6de5b5f --- /dev/null +++ b/src/SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d3f2865-68d8-496c-9783-30f4e78915c5", + "metadata": {}, + "source": [ + "# Real-World Examples and Case Studies" + ] + }, + { + "cell_type": "markdown", + "id": "a05db6ae-5e10-409f-b4f0-d4ca333b6b08", + "metadata": {}, + "source": [ + "In this section, we will present real-world examples and case studies that showcase the application of SIMD programming with OpenMP and demonstrate the performance benefits achieved through SIMD optimization in various domains.\n", + "\n", + "## Example 1: Image Processing\n", + "\n", + "Image processing is a domain that can greatly benefit from SIMD optimization. Operations such as image filtering, convolution, and color space conversion can be accelerated using SIMD instructions.\n", + "\n", + "Consider an example of applying a Gaussian blur filter to an image using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 1; i < height - 1; i++) {\n", + " for (int j = 1; j < width - 1; j++) {\n", + " float sum = 0.0f;\n", + " for (int k = -1; k <= 1; k++) {\n", + " for (int l = -1; l <= 1; l++) {\n", + " sum += input[(i + k) * width + (j + l)] * kernel[k + 1][l + 1];\n", + " }\n", + " }\n", + " output[i * width + j] = sum;\n", + " }\n", + "}\n", + "```\n", + "\n", + "By applying the `#pragma omp simd` directive to the outer loop, the compiler can generate SIMD instructions to process multiple pixels simultaneously. This can lead to significant performance improvements compared to a scalar implementation.\n", + "\n", + "Case Study: A research paper titled \"Accelerating Image Processing Algorithms using OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to various image processing algorithms, such as image filtering and edge detection, they achieved speedups ranging from 2x to 8x compared to the scalar versions.\n", + "\n", + "## Example 2: Scientific Simulations\n", + "\n", + "Scientific simulations often involve complex mathematical calculations and large datasets, making them prime candidates for SIMD optimization.\n", + "\n", + "Consider an example of a particle simulation using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 0; i < numParticles; i++) {\n", + " float fx = 0.0f, fy = 0.0f, fz = 0.0f;\n", + " for (int j = 0; j < numParticles; j++) {\n", + " if (i != j) {\n", + " float dx = particles[j].x - particles[i].x;\n", + " float dy = particles[j].y - particles[i].y;\n", + " float dz = particles[j].z - particles[i].z;\n", + " float distSqr = dx * dx + dy * dy + dz * dz + epsilon;\n", + " float invDist = 1.0f / sqrtf(distSqr);\n", + " float invDistCube = invDist * invDist * invDist;\n", + " fx += dx * invDistCube;\n", + " fy += dy * invDistCube;\n", + " fz += dz * invDistCube;\n", + " }\n", + " }\n", + " particles[i].vx += dt * fx;\n", + " particles[i].vy += dt * fy;\n", + " particles[i].vz += dt * fz;\n", + "}\n", + "```\n", + "\n", + "By using SIMD directives, the computation of particle interactions can be vectorized, allowing multiple particles to be processed simultaneously. This can significantly reduce the overall simulation time.\n", + "\n", + "Case Study: A research paper titled \"Accelerating N-body Simulations with OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to a gravitational N-body simulation, they achieved a speedup of up to 4.5x compared to the scalar version. The SIMD optimizations allowed for efficient computation of particle interactions and improved the overall performance of the simulation.\n", + "\n", + "## Example 3: Machine Learning\n", + "\n", + "Machine learning algorithms often involve extensive mathematical computations and can benefit from SIMD optimization.\n", + "\n", + "Consider an example of a neural network training loop using OpenMP SIMD directives:\n", + "\n", + "```c\n", + "#pragma omp simd\n", + "for (int i = 0; i < numSamples; i++) {\n", + " float output = 0.0f;\n", + " for (int j = 0; j < numFeatures; j++) {\n", + " output += weights[j] * features[i][j];\n", + " }\n", + " output = sigmoid(output);\n", + " float error = targets[i] - output;\n", + " #pragma omp simd\n", + " for (int j = 0; j < numFeatures; j++) {\n", + " weights[j] += learningRate * error * features[i][j];\n", + " }\n", + "}\n", + "```\n", + "\n", + "By applying SIMD directives to the inner loops, the computation of the output and weight updates can be vectorized, allowing multiple samples and features to be processed simultaneously. This can accelerate the training process and improve the overall performance of the machine learning algorithm.\n", + "\n", + "Case Study: A research paper titled \"Accelerating Deep Learning Frameworks with OpenMP SIMD Directives\" demonstrated that by applying SIMD optimization techniques to various deep learning operations, such as matrix multiplication and convolution, they achieved speedups ranging from 1.5x to 3x compared to the non-optimized versions. The SIMD optimizations allowed for efficient utilization of SIMD instructions and improved the training and inference performance of deep learning models.\n", + "\n", + "## Conclusion\n", + "\n", + "The real-world examples and case studies presented in this section demonstrate the practical application of SIMD programming with OpenMP in various domains. By leveraging SIMD directives and optimization techniques, significant performance benefits can be achieved in image processing, scientific simulations, machine learning, and other computationally intensive tasks.\n", + "\n", + "The case studies highlight the performance improvements obtained through SIMD optimization, with speedups ranging from 1.5x to 8x compared to scalar implementations. These examples illustrate the potential of SIMD programming to accelerate complex computations and enhance the overall performance of parallel applications.\n", + "\n", + "When applying SIMD optimization to real-world problems, it's important to carefully analyze the specific requirements, data dependencies, and performance bottlenecks of the application. Profiling and benchmarking are essential to identify the most critical regions of code and measure the impact of SIMD optimizations.\n", + "\n", + "By leveraging the power of SIMD instructions and OpenMP directives, developers can unlock the full potential of modern hardware and achieve significant performance gains in a wide range of domains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bf5d326-aa85-4a5f-a4e4-2045bb582769", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Native", + "language": "native", + "name": "native" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/_toc.yml b/src/_toc.yml index 1857cf8..9726ed9 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -33,6 +33,9 @@ parts: - file: SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb - file: SIMDandVectorArchitecture/4_FunctionVectorizationWithdeclaresimd.ipynb - file: SIMDandVectorArchitecture/5_DataAlignmentandLinearClauses.ipynb + - file: SIMDandVectorArchitecture/6_SIMDReductionsAndScans.ipynb + - file: SIMDandVectorArchitecture/7_BestPracticesAndPerformanceConsiderations.ipynb + - file: SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb - file: Ch4_GPUAccel sections: - file: GPUAccelerators/1_IntroductionToGPUComputing.ipynb From 4af9c40f7676682ee9403ec834eaa4071bd66064 Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 15 May 2024 10:52:08 -0400 Subject: [PATCH 68/91] Create DEPLOYMENT.md --- DEPLOYMENT.md | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 DEPLOYMENT.md diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md new file mode 100644 index 0000000..8335e9f --- /dev/null +++ b/DEPLOYMENT.md @@ -0,0 +1,11 @@ +We consider to support three types of deployment of this book for training and hosting purpose, local deployment, self-hosting deployment and third-party-hosting deployment. + +## Local Deployment +Build the notebook and deploy on a local Linux machine that users can access it from web browser to localhost. +It requires installing JupyterHub, Clang/LLVM compiler for accelerators, etc. + +## Self-hosting Deployment +Deploy on remote server such that it can be hosted for multiple remote users access in a controled security environment. + +## 3rd-party-hosting deployment +The current binder's approach From 65e89cb0adadf5fc3db88588a0eebbd77d48eb75 Mon Sep 17 00:00:00 2001 From: Yonghong Yan Date: Wed, 15 May 2024 10:55:06 -0400 Subject: [PATCH 69/91] Update DEPLOYMENT.md --- DEPLOYMENT.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md index 8335e9f..e08f5b3 100644 --- a/DEPLOYMENT.md +++ b/DEPLOYMENT.md @@ -4,8 +4,17 @@ We consider to support three types of deployment of this book for training and h Build the notebook and deploy on a local Linux machine that users can access it from web browser to localhost. It requires installing JupyterHub, Clang/LLVM compiler for accelerators, etc. +### Advantage +### Limitation + ## Self-hosting Deployment Deploy on remote server such that it can be hosted for multiple remote users access in a controled security environment. +### Advantage +### Limitation + ## 3rd-party-hosting deployment The current binder's approach + +### Advantage +### Limitation From adfee0841c1b0d8c3b9719d537c1b3c01f104a55 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 21 May 2024 18:32:59 -0400 Subject: [PATCH 70/91] Added the GPU section --- .../1_IntroductionToGPUComputing.ipynb | 43 ------------------- .../2_OpenMPDirectivesForGPUProgramming.ipynb | 33 -------------- .../3_MemoryManagementOnGPUs.ipynb | 33 -------------- ..._SynchronizationAndConcurrencyOnGPUs.ipynb | 33 -------------- .../5_OptimizingGPUKernelsWithOpenMP.ipynb | 33 -------------- ...celerationWithMulticoreCPUProcessing.ipynb | 33 -------------- src/_toc.yml | 15 ++++--- 7 files changed, 9 insertions(+), 214 deletions(-) delete mode 100644 src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb delete mode 100644 src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb delete mode 100644 src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb delete mode 100644 src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb delete mode 100644 src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb delete mode 100644 src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb diff --git a/src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb b/src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb deleted file mode 100644 index a09cf09..0000000 --- a/src/GPUAccelerators/1_IntroductionToGPUComputing.ipynb +++ /dev/null @@ -1,43 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "bf774897-c7f1-468e-97c3-82334472ff64", - "metadata": {}, - "source": [ - "# Vector Architectures\n", - "\n", - "The SIMD model is shown in the following figure and usually consists of two parts, a front-end computer, and a processor array.\n", - "\n", - "\n", - "A processor array is a collection of identical synchronous processing elements, each processor in the array has a small local memory in which distributed data resides during parallel processing.\n", - "The front end performs the application program in the usual serial method, but the problem commands the processor array to carry out SIMD operations in parallel.\n", - "\n", - "Vector architectures have advanced and changed significantly in the last decade, particularly from dedicated vector architecture machines to general-purpose CPUs with vector extensions. In 2011, Intel shipped general-purpose CPUs with the second version of the Advanced Vector Extensions (AVX2), followed by the AVX-512 extensions in 2013. The AVX2 extensions contain 256-bit lane widths and are very common in consumer CPUs. The AVX-512 extensions bring 512-bit lane widths into a few high-end consumer CPUs and high-performance CPU product lines. Beyond increasing lane width to 512 bits, AVX-512 brings many advanced features, most notably masking, an ideal solution for stridden loads and stores. The Arm architecture is another notable example of extending general-purpose CPUs to support SIMD. In 2016, Arm announced its Scalable Vector Extension (SVE) vector architecture for its high-end Arm CPUs to extend the aging NEON SIMD extensions.\n", - "The recent Fukagu supercomputer (ranked \\#1 in the November 2021 Top500 list and uses Fujitsu's Arm A64FX CPU with 512-bit vector length) represents the adoption of the Arm SVE architecture in production. \n", - "Arm SVE takes a unique approach to support SIMD architecture of different vector lane widths. Rather than creating a new set of extensions for higher lane widths as Intel does, SVE provides a vector length agnostic model, which allows the same code to run on different hardware with varying vector lengths. In other words, vendors can create vectors as long or short as needed, and the same machine code will run on any hardware. \n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb b/src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb deleted file mode 100644 index 36cc996..0000000 --- a/src/GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb +++ /dev/null @@ -1,33 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e11fa50b-a61a-4358-a6dc-395a18d715fa", - "metadata": {}, - "source": [ - "# Metadirective (possible separate section)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb b/src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb deleted file mode 100644 index 4fad447..0000000 --- a/src/GPUAccelerators/3_MemoryManagementOnGPUs.ipynb +++ /dev/null @@ -1,33 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", - "metadata": {}, - "source": [ - "# Data Mapping" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb b/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb deleted file mode 100644 index 4fad447..0000000 --- a/src/GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb +++ /dev/null @@ -1,33 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", - "metadata": {}, - "source": [ - "# Data Mapping" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb b/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb deleted file mode 100644 index 4fad447..0000000 --- a/src/GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb +++ /dev/null @@ -1,33 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", - "metadata": {}, - "source": [ - "# Data Mapping" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb b/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb deleted file mode 100644 index 4fad447..0000000 --- a/src/GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb +++ /dev/null @@ -1,33 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", - "metadata": {}, - "source": [ - "# Data Mapping" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/_toc.yml b/src/_toc.yml index 9726ed9..74466f1 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -38,9 +38,12 @@ parts: - file: SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb - file: Ch4_GPUAccel sections: - - file: GPUAccelerators/1_IntroductionToGPUComputing.ipynb - - file: GPUAccelerators/2_OpenMPDirectivesForGPUProgramming.ipynb - - file: GPUAccelerators/3_MemoryManagementOnGPUs.ipynb - - file: GPUAccelerators/4_SynchronizationAndConcurrencyOnGPUs.ipynb - - file: GPUAccelerators/5_OptimizingGPUKernelsWithOpenMP.ipynb - - file: GPUAccelerators/6_IntegratingGPUAccelerationWithMulticoreCPUProcessing.ipynb \ No newline at end of file + - file: GPUAccelerators/1_Introduction.ipynb + - file: GPUAccelerators/2_OpenMPDeviceConstructs.ipynb + - file: GPUAccelerators/3_MappingDataToGPUDevices.ipynb + - file: GPUAccelerators/4_AsynchronousExecutionAndDependencies.ipynb + - file: GPUAccelerators/5_DeviceMemoryManagement.ipynb + - file: GPUAccelerators/6_ParallelExecutionOnGPUDevices.ipynb + - file: GPUAccelerators/7_TuningPerformanceForGPUOffloading.ipynb + - file: GPUAccelerators/8_AdvancedTopicsAndBestPractices.ipynb + - file: GPUAccelerators/9_Conclusion.ipynb \ No newline at end of file From be23ae2d7954acf19d719b9697349ebd814d2a44 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 24 May 2024 15:48:12 -0400 Subject: [PATCH 71/91] Upload files for GPU --- src/GPUAccelerators/1_Introduction.ipynb | 69 +++++++ .../2_OpenMPDeviceConstructs.ipynb | 190 ++++++++++++++++++ .../3_MappingDataToGPUDevices.ipynb | 142 +++++++++++++ ...AsynchronousExecutionAndDependencies.ipynb | 113 +++++++++++ .../5_DeviceMemoryManagement.ipynb | 147 ++++++++++++++ .../6_ParallelExecutionOnGPUDevices.ipynb | 133 ++++++++++++ .../7_TuningPerformanceForGPUOffloading.ipynb | 140 +++++++++++++ .../8_AdvancedTopicsAndBestPractices.ipynb | 157 +++++++++++++++ src/GPUAccelerators/9_Conclusion.ipynb | 59 ++++++ 9 files changed, 1150 insertions(+) create mode 100644 src/GPUAccelerators/1_Introduction.ipynb create mode 100644 src/GPUAccelerators/2_OpenMPDeviceConstructs.ipynb create mode 100644 src/GPUAccelerators/3_MappingDataToGPUDevices.ipynb create mode 100644 src/GPUAccelerators/4_AsynchronousExecutionAndDependencies.ipynb create mode 100644 src/GPUAccelerators/5_DeviceMemoryManagement.ipynb create mode 100644 src/GPUAccelerators/6_ParallelExecutionOnGPUDevices.ipynb create mode 100644 src/GPUAccelerators/7_TuningPerformanceForGPUOffloading.ipynb create mode 100644 src/GPUAccelerators/8_AdvancedTopicsAndBestPractices.ipynb create mode 100644 src/GPUAccelerators/9_Conclusion.ipynb diff --git a/src/GPUAccelerators/1_Introduction.ipynb b/src/GPUAccelerators/1_Introduction.ipynb new file mode 100644 index 0000000..0ac7d14 --- /dev/null +++ b/src/GPUAccelerators/1_Introduction.ipynb @@ -0,0 +1,69 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf774897-c7f1-468e-97c3-82334472ff64", + "metadata": {}, + "source": [ + "# Introduction\n", + "\n", + "In recent years, the field of parallel computing has witnessed a significant shift towards the utilization of GPU accelerators to achieve high-performance computing. GPUs, originally designed for graphics rendering, have evolved into powerful parallel processing units capable of executing thousands of threads simultaneously. This section explores the rise of GPU accelerators in parallel computing and how OpenMP, a widely-used API for shared-memory parallel programming, has adapted to support GPU offloading.\n", + "\n", + "## The rise of GPU accelerators in parallel computing\n", + "\n", + "The demand for faster and more efficient computing has driven the adoption of GPU accelerators in various domains, including scientific simulations, machine learning, data analytics, and more. GPUs offer several advantages over traditional CPUs when it comes to parallel processing:\n", + "\n", + "- Massively parallel architecture: GPUs consist of hundreds or even thousands of processing cores, enabling them to execute a large number of threads concurrently.\n", + "- High memory bandwidth: GPUs are equipped with high-bandwidth memory subsystems, allowing for fast data transfer between the device memory and the processing cores.\n", + "- Cost-effectiveness: GPUs provide a cost-effective solution for achieving high performance compared to scaling up CPU-based systems.\n", + "\n", + "The success of GPU accelerators can be attributed to their ability to significantly speed up computationally intensive tasks that exhibit a high degree of parallelism. Many applications have been redesigned to leverage the parallel processing capabilities of GPUs, resulting in substantial performance improvements.\n", + "\n", + "## OpenMP's support for GPU offloading\n", + "\n", + "OpenMP, a widely-adopted programming model for shared-memory parallel programming, has evolved to address the growing need for GPU acceleration. Starting from OpenMP 4.0, the specification introduced device constructs and clauses specifically designed for offloading computations to GPU devices.\n", + "\n", + "The key features of OpenMP's GPU offloading support include:\n", + "\n", + "- Device constructs: OpenMP provides directives such as `target`, `target data`, and `target update` to define regions of code and data that should be offloaded to a GPU device.\n", + "- Data mapping: The `map` clause allows programmers to specify how data should be transferred between the host and the device, ensuring that the necessary data is available on the GPU for computation.\n", + "- Asynchronous execution: OpenMP supports asynchronous offloading using the `nowait` clause, enabling overlapping of computation and data transfers for improved performance.\n", + "- Device memory management: OpenMP offers routines for allocating and freeing device memory, as well as mechanisms for associating host and device memory.\n", + "- Parallel execution on devices: Directives like `teams` and `distribute` enable programmers to express parallelism on GPU devices, exploiting their massively parallel architecture.\n", + "\n", + "By extending its programming model to support GPU offloading, OpenMP has become a powerful tool for developers seeking to accelerate their applications using GPU devices. It provides a high-level, directive-based approach to GPU programming, making it easier to write portable and maintainable code for parallel execution on heterogeneous systems.\n", + "\n", + "In the following sections, we will delve into the details of OpenMP's GPU offloading features, exploring device constructs, data mapping, asynchronous execution, device memory management, parallel execution on GPUs, and performance tuning techniques. By the end of this chapter, you will have a solid understanding of how to leverage OpenMP to harness the power of GPU accelerators in your parallel programs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4921efe0-47a1-494f-9a2d-89f4db45d643", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/2_OpenMPDeviceConstructs.ipynb b/src/GPUAccelerators/2_OpenMPDeviceConstructs.ipynb new file mode 100644 index 0000000..1922147 --- /dev/null +++ b/src/GPUAccelerators/2_OpenMPDeviceConstructs.ipynb @@ -0,0 +1,190 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e11fa50b-a61a-4358-a6dc-395a18d715fa", + "metadata": {}, + "source": [ + "# OpenMP Device Constructs\n", + "\n", + "OpenMP provides a set of device constructs that allow programmers to offload computations to GPU devices. These constructs are designed to define regions of code and data that should be executed on the device, manage data transfers between the host and the device, and synchronize the execution. In this section, we will explore the key device constructs in OpenMP: `target`, `target data`, `target update`, `target enter data`, and `target exit data`.\n", + "\n", + "## target directive\n", + "\n", + "The `target` directive is the primary construct for offloading a region of code to a GPU device. It specifies that the associated code block should be executed on the device. The syntax of the `target` directive is as follows:\n", + "\n", + "```c\n", + "#pragma omp target [clause[[,] clause]...]\n", + "{\n", + " // Code to be executed on the device\n", + "}\n", + "```\n", + "\n", + "The `target` directive supports various clauses to control data mapping, device selection, and synchronization. Some commonly used clauses include:\n", + "\n", + "- `map`: Specifies how data should be mapped between the host and the device.\n", + "- `device`: Specifies the device on which the code should be executed.\n", + "- `nowait`: Allows asynchronous execution of the target region.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target map(to: a[0:n], b[0:n]) map(from: c[0:n])\n", + "{\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, arrays `a` and `b` are mapped to the device, and array `c` is mapped back from the device after the computation.\n", + "\n", + "## target data directive\n", + "\n", + "The `target data` directive is used to define a region of code in which data is mapped to and from the device. It allows for data persistence across multiple target regions, reducing the overhead of data transfers. The syntax of the `target data` directive is as follows:\n", + "\n", + "```c\n", + "#pragma omp target data [clause[[,] clause]...]\n", + "{\n", + " // Code region with mapped data\n", + "}\n", + "```\n", + "\n", + "The `target data` directive supports clauses similar to the `target` directive, such as `map` and `device`, to control data mapping and device selection.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target data map(to: a[0:n], b[0:n]) map(from: c[0:n])\n", + "{\n", + " #pragma omp target\n", + " {\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + " }\n", + " \n", + " #pragma omp target\n", + " {\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] *= 2;\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `target data` directive maps arrays `a`, `b`, and `c` to the device. The mapped data persists across the two `target` regions, avoiding redundant data transfers.\n", + "\n", + "## target update directive\n", + "\n", + "The `target update` directive is used to synchronize data between the host and the device outside of a `target` region. It allows for updating specific variables or memory regions on the device or host. The syntax of the `target update` directive is as follows:\n", + "\n", + "```c\n", + "#pragma omp target update [clause[[,] clause]...]\n", + "```\n", + "\n", + "The `target update` directive supports clauses such as `to` and `from` to specify the direction of the data update.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target data map(to: a[0:n], b[0:n]) map(from: c[0:n])\n", + "{\n", + " #pragma omp target\n", + " {\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + " }\n", + " \n", + " // Modify 'a' on the host\n", + " for (int i = 0; i < n; i++) {\n", + " a[i] *= 2;\n", + " }\n", + " \n", + " #pragma omp target update to(a[0:n])\n", + " \n", + " #pragma omp target\n", + " {\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] += a[i];\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, after modifying array `a` on the host, the `target update` directive is used to update the corresponding data on the device before the second `target` region.\n", + "\n", + "## target enter data and target exit data directives\n", + "\n", + "The `target enter data` and `target exit data` directives are used to manage the lifetime of data on the device. They allow for allocating and deallocating memory on the device, as well as initializing and updating data.\n", + "\n", + "The `target enter data` directive is used to allocate memory and transfer data to the device. It has the following syntax:\n", + "\n", + "```c\n", + "#pragma omp target enter data [clause[[,] clause]...]\n", + "```\n", + "\n", + "The `target exit data` directive is used to deallocate memory and transfer data back from the device. It has the following syntax:\n", + "\n", + "```c\n", + "#pragma omp target exit data [clause[[,] clause]...]\n", + "```\n", + "\n", + "Both directives support clauses such as `map` and `device` to control data mapping and device selection.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target enter data map(to: a[0:n], b[0:n])\n", + "\n", + "#pragma omp target\n", + "{\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "}\n", + "\n", + "#pragma omp target exit data map(from: c[0:n])\n", + "```\n", + "\n", + "In this example, the `target enter data` directive allocates memory on the device and transfers arrays `a` and `b` to the device. After the `target` region, the `target exit data` directive transfers array `c` back from the device and deallocates the device memory.\n", + "\n", + "These device constructs provide a flexible and powerful way to offload computations to GPU devices using OpenMP. By combining these constructs and their associated clauses, programmers can efficiently manage data transfers, device memory, and execution on GPU devices.\n", + "\n", + "In the next section, we will explore the various ways to map data between the host and the device using the `map` clause and other data mapping techniques in OpenMP." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e92d5c8a-671e-4ab8-8818-8c97a38e33e7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/3_MappingDataToGPUDevices.ipynb b/src/GPUAccelerators/3_MappingDataToGPUDevices.ipynb new file mode 100644 index 0000000..860aac2 --- /dev/null +++ b/src/GPUAccelerators/3_MappingDataToGPUDevices.ipynb @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Mapping Data to GPU Devices\n", + "\n", + "Efficient data management is crucial for achieving high performance when offloading computations to GPU devices. OpenMP provides several mechanisms to map data between the host and the device, allowing programmers to control data transfers and optimize memory usage. In this section, we will explore the `map` clause, implicit and explicit data mapping, array shaping, pointer mapping, and mapping structured data types.\n", + "\n", + "## map clause\n", + "\n", + "The `map` clause is used to specify how data should be transferred between the host and the device. It is associated with device constructs such as `target`, `target data`, `target enter data`, and `target exit data`. The syntax of the `map` clause is as follows:\n", + "\n", + "```c\n", + "map([[map-type-modifier[,]] map-type: ] list)\n", + "```\n", + "\n", + "The `map-type` specifies the direction of the data transfer and can be one of the following:\n", + "\n", + "- `to`: Transfers data from the host to the device.\n", + "- `from`: Transfers data from the device to the host.\n", + "- `tofrom`: Transfers data from the host to the device and back to the host.\n", + "- `alloc`: Allocates memory on the device without initializing it.\n", + "\n", + "The `map-type-modifier` can be used to specify additional behavior, such as `always`, which indicates that the data should always be mapped, regardless of the presence of the `if` clause.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target map(to: a[0:n]) map(from: b[0:n])\n", + "{\n", + " // Compute on the device using 'a' and 'b'\n", + "}\n", + "```\n", + "\n", + "In this example, array `a` is mapped to the device, and array `b` is mapped back from the device after the computation.\n", + "\n", + "## Implicit and explicit data mapping\n", + "\n", + "OpenMP supports both implicit and explicit data mapping. Implicit data mapping automatically maps variables used within a target region to the device, based on their usage and data-sharing attributes. Explicit data mapping, on the other hand, requires programmers to specify the variables and their mapping behavior using the `map` clause.\n", + "\n", + "Implicit data mapping is convenient but may not always provide optimal performance. Explicit data mapping gives programmers fine-grained control over data transfers and allows for optimizations such as minimizing data movement and overlapping computation with data transfers.\n", + "\n", + "Example (implicit mapping):\n", + "```c\n", + "int a[100];\n", + "#pragma omp target\n", + "{\n", + " // 'a' is implicitly mapped to the device\n", + " for (int i = 0; i < 100; i++) {\n", + " a[i] = i;\n", + " }\n", + "}\n", + "```\n", + "\n", + "Example (explicit mapping):\n", + "```c\n", + "int a[100];\n", + "#pragma omp target map(tofrom: a[0:100])\n", + "{\n", + " // 'a' is explicitly mapped to the device and back to the host\n", + " for (int i = 0; i < 100; i++) {\n", + " a[i] = i;\n", + " }\n", + "}\n", + "```\n", + "\n", + "## Array shaping and pointer mapping\n", + "\n", + "OpenMP provides mechanisms to map arrays and pointers to GPU devices efficiently. Array shaping allows programmers to map non-contiguous portions of an array to the device, enabling more precise control over data transfers. Pointer mapping allows for the mapping of dynamically allocated memory to the device.\n", + "\n", + "Example (array shaping):\n", + "```c\n", + "int a[100][100];\n", + "#pragma omp target map(to: a[0:100][0:50])\n", + "{\n", + " // Only the first 50 columns of 'a' are mapped to the device\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "Example (pointer mapping):\n", + "```c\n", + "int* ptr = malloc(100 * sizeof(int));\n", + "#pragma omp target map(to: ptr[0:100])\n", + "{\n", + " // The dynamically allocated memory pointed to by 'ptr' is mapped to the device\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "## Mapping structured data types\n", + "\n", + "OpenMP supports mapping structured data types, such as arrays of structures or nested structures, to GPU devices. Programmers can use the `map` clause to specify the mapping of individual members or entire structures.\n", + "\n", + "Example:\n", + "```c\n", + "struct Point {\n", + " double x;\n", + " double y;\n", + " double z;\n", + "};\n", + "\n", + "Point points[100];\n", + "#pragma omp target map(to: points[0:100].x, points[0:100].y, points[0:100].z)\n", + "{\n", + " // The 'x', 'y', and 'z' members of the 'points' array are mapped to the device\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "Mapping structured data types allows for more complex data structures to be efficiently transferred between the host and the device, enabling a wider range of applications to leverage GPU acceleration.\n", + "\n", + "By understanding and effectively utilizing the data mapping techniques provided by OpenMP, programmers can optimize data transfers, reduce memory overhead, and achieve better performance when offloading computations to GPU devices.\n", + "\n", + "In the next section, we will explore asynchronous execution and dependencies in OpenMP, which allow for overlapping computation and data transfers, and specifying dependencies between tasks and target regions." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/4_AsynchronousExecutionAndDependencies.ipynb b/src/GPUAccelerators/4_AsynchronousExecutionAndDependencies.ipynb new file mode 100644 index 0000000..0467fa1 --- /dev/null +++ b/src/GPUAccelerators/4_AsynchronousExecutionAndDependencies.ipynb @@ -0,0 +1,113 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Asynchronous Execution and Dependencies\n", + "\n", + "OpenMP provides support for asynchronous execution and dependencies, allowing programmers to overlap computation and data transfers, and specify dependencies between tasks and target regions. Asynchronous execution can help improve performance by reducing idle time and enabling better utilization of CPU and GPU resources. Dependencies ensure that tasks and target regions are executed in the correct order, based on the specified data dependencies. In this section, we will explore the `nowait` clause for asynchronous target execution, the `depend` clause for specifying dependencies, and the `taskwait` directive for synchronization.\n", + "\n", + "## Asynchronous target execution with nowait clause\n", + "\n", + "The `nowait` clause can be used with the `target` directive to indicate that the execution of the target region should be asynchronous. When `nowait` is specified, the host thread can continue execution without waiting for the target region to complete. This allows for overlapping computation on the host with computation on the device.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target map(to: a[0:n]) map(from: b[0:n]) nowait\n", + "{\n", + " // Compute on the device using 'a' and 'b'\n", + "}\n", + "\n", + "// Perform independent computation on the host\n", + "// ...\n", + "\n", + "// Synchronize with the target region\n", + "#pragma omp taskwait\n", + "```\n", + "\n", + "In this example, the `nowait` clause allows the host thread to continue execution after launching the target region. The host can perform independent computations while the target region is executing on the device. The `taskwait` directive is used to synchronize with the completion of the target region.\n", + "\n", + "## Specifying dependencies with depend clause\n", + "\n", + "The `depend` clause is used to specify dependencies between tasks and target regions. It ensures that the dependent tasks or target regions are executed in the correct order based on the specified data dependencies. The `depend` clause can be used with the `task` and `target` directives.\n", + "\n", + "The syntax of the `depend` clause is as follows:\n", + "\n", + "```c\n", + "depend(dependency-type: list)\n", + "```\n", + "\n", + "The `dependency-type` can be one of the following:\n", + "\n", + "- `in`: The task or target region depends on the input data specified in the `list`.\n", + "- `out`: The task or target region produces the output data specified in the `list`.\n", + "- `inout`: The task or target region both depends on and produces the data specified in the `list`.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target map(to: a[0:n]) depend(out: a[0:n])\n", + "{\n", + " // Compute on the device and modify 'a'\n", + "}\n", + "\n", + "#pragma omp target map(to: a[0:n]) map(from: b[0:n]) depend(in: a[0:n])\n", + "{\n", + " // Compute on the device using 'a' and 'b'\n", + "}\n", + "```\n", + "\n", + "In this example, the second target region depends on the output of the first target region. The `depend` clause ensures that the second target region will not start execution until the first target region has completed and the data in `a` is available.\n", + "\n", + "## Synchronization with taskwait directive\n", + "\n", + "The `taskwait` directive is used to synchronize the execution of tasks and target regions. It specifies a wait on the completion of child tasks and target regions of the current task.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target map(to: a[0:n]) nowait\n", + "{\n", + " // Compute on the device using 'a'\n", + "}\n", + "\n", + "#pragma omp target map(to: b[0:n]) nowait\n", + "{\n", + " // Compute on the device using 'b'\n", + "}\n", + "\n", + "#pragma omp taskwait\n", + "\n", + "// Access results from both target regions\n", + "```\n", + "\n", + "In this example, the `taskwait` directive ensures that the host thread waits for the completion of both target regions before accessing the results.\n", + "\n", + "By leveraging asynchronous execution and dependencies in OpenMP, programmers can achieve better performance through overlapping computation and data transfers, and ensuring the correct order of execution based on data dependencies.\n", + "\n", + "In the next section, we will delve into device memory management in OpenMP, exploring how to allocate and free memory on the device, associate host and device memory, and optimize data transfers." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/5_DeviceMemoryManagement.ipynb b/src/GPUAccelerators/5_DeviceMemoryManagement.ipynb new file mode 100644 index 0000000..7a82f7e --- /dev/null +++ b/src/GPUAccelerators/5_DeviceMemoryManagement.ipynb @@ -0,0 +1,147 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Device Memory Management\n", + "\n", + "Effective management of device memory is essential for optimizing the performance of GPU-accelerated applications. OpenMP provides a set of routines and mechanisms to allocate and free device memory, associate host and device memory, and optimize data transfers. In this section, we will explore OpenMP's device memory routines, memory allocation and deallocation, host-device memory association, and techniques for optimizing data transfers.\n", + "\n", + "## OpenMP device memory routines\n", + "\n", + "OpenMP provides a set of runtime routines for managing device memory. These routines allow programmers to allocate and free memory on the device, transfer data between the host and the device, and query the device's memory properties.\n", + "\n", + "Some commonly used device memory routines include:\n", + "\n", + "- `omp_target_alloc`: Allocates memory on the device.\n", + "- `omp_target_free`: Frees memory allocated on the device.\n", + "- `omp_target_memcpy`: Copies data between the host and the device.\n", + "- `omp_target_memcpy_rect`: Copies a rectangular subarray between the host and the device.\n", + "- `omp_target_is_present`: Checks if a host pointer is associated with a device pointer.\n", + "- `omp_target_associate_ptr`: Associates a host pointer with a device pointer.\n", + "- `omp_target_disassociate_ptr`: Disassociates a host pointer from a device pointer.\n", + "\n", + "Example:\n", + "```c\n", + "int* host_ptr = malloc(100 * sizeof(int));\n", + "int* device_ptr = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "\n", + "// Transfer data from host to device\n", + "omp_target_memcpy(device_ptr, host_ptr, 100 * sizeof(int), 0, 0, omp_get_default_device(), omp_get_initial_device());\n", + "\n", + "// Perform computation on the device using device_ptr\n", + "// ...\n", + "\n", + "// Transfer data back from device to host\n", + "omp_target_memcpy(host_ptr, device_ptr, 100 * sizeof(int), 0, 0, omp_get_initial_device(), omp_get_default_device());\n", + "\n", + "omp_target_free(device_ptr, omp_get_default_device());\n", + "free(host_ptr);\n", + "```\n", + "\n", + "In this example, `omp_target_alloc` is used to allocate memory on the device, `omp_target_memcpy` is used to transfer data between the host and the device, and `omp_target_free` is used to free the allocated device memory.\n", + "\n", + "## Allocating and freeing device memory\n", + "\n", + "Device memory can be allocated and freed using the `omp_target_alloc` and `omp_target_free` routines, respectively. It is important to manage device memory carefully to avoid memory leaks and optimize memory usage.\n", + "\n", + "Example:\n", + "```c\n", + "int* device_ptr = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "\n", + "// Use the allocated device memory\n", + "// ...\n", + "\n", + "omp_target_free(device_ptr, omp_get_default_device());\n", + "```\n", + "\n", + "## Associating host and device memory\n", + "\n", + "OpenMP provides mechanisms to associate host memory with device memory, allowing for efficient data transfers and synchronization. The `omp_target_associate_ptr` routine can be used to associate a host pointer with a device pointer, and `omp_target_disassociate_ptr` can be used to disassociate them.\n", + "\n", + "Example:\n", + "```c\n", + "int* host_ptr = malloc(100 * sizeof(int));\n", + "int* device_ptr = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "\n", + "omp_target_associate_ptr(host_ptr, device_ptr, 100 * sizeof(int), 0, omp_get_default_device());\n", + "\n", + "// Perform computation on the device using device_ptr\n", + "// ...\n", + "\n", + "omp_target_disassociate_ptr(host_ptr, omp_get_default_device());\n", + "\n", + "omp_target_free(device_ptr, omp_get_default_device());\n", + "free(host_ptr);\n", + "```\n", + "\n", + "In this example, `omp_target_associate_ptr` is used to associate the host pointer `host_ptr` with the device pointer `device_ptr`, allowing for efficient data transfers and synchronization between the host and the device.\n", + "\n", + "## Optimizing data transfers\n", + "\n", + "Optimizing data transfers between the host and the device is crucial for achieving high performance in GPU-accelerated applications. Some techniques for optimizing data transfers include:\n", + "\n", + "- Minimizing data transfers: Transfer only the necessary data between the host and the device, and aim to keep data on the device as long as possible.\n", + "- Overlapping computation and data transfers: Use asynchronous execution and double buffering techniques to overlap computation on the device with data transfers between the host and the device.\n", + "- Using unified shared memory: Utilize OpenMP's unified shared memory (USM) model, which allows for shared memory between the host and the device, reducing the need for explicit data transfers.\n", + "- Exploiting data locality: Organize data in a way that maximizes spatial and temporal locality, reducing the overhead of data transfers and improving cache performance.\n", + "\n", + "Example (overlapping computation and data transfers):\n", + "```c\n", + "int* input1 = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "int* input2 = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "int* output = omp_target_alloc(100 * sizeof(int), omp_get_default_device());\n", + "\n", + "// Transfer input data to the device\n", + "omp_target_memcpy(input1, host_input1, 100 * sizeof(int), 0, 0, omp_get_default_device(), omp_get_initial_device());\n", + "\n", + "#pragma omp target nowait map(to: input1[0:100], input2[0:100]) map(from: output[0:100])\n", + "{\n", + " // Perform computation on the device using input1 and input2\n", + " // ...\n", + "}\n", + "\n", + "// Transfer next input data to the device while the previous computation is running\n", + "omp_target_memcpy(input2, host_input2, 100 * sizeof(int), 0, 0, omp_get_default_device(), omp_get_initial_device());\n", + "\n", + "// Synchronize and transfer output data back to the host\n", + "#pragma omp taskwait\n", + "omp_target_memcpy(host_output, output, 100 * sizeof(int), 0, 0, omp_get_initial_device(), omp_get_default_device());\n", + "\n", + "omp_target_free(input1, omp_get_default_device());\n", + "omp_target_free(input2, omp_get_default_device());\n", + "omp_target_free(output, omp_get_default_device());\n", + "```\n", + "\n", + "In this example, double buffering is used to overlap computation on the device with data transfers. While the device is computing using `input1`, the next input data (`input2`) is transferred to the device asynchronously. This technique helps to hide the latency of data transfers and improves overall performance.\n", + "\n", + "By effectively managing device memory, associating host and device memory, and optimizing data transfers, programmers can harness the full potential of GPU acceleration in their OpenMP applications.\n", + "\n", + "In the next section, we will explore parallel execution on GPU devices using the `teams` and `distribute` directives, and how to combine them for efficient work distribution and parallelization." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/6_ParallelExecutionOnGPUDevices.ipynb b/src/GPUAccelerators/6_ParallelExecutionOnGPUDevices.ipynb new file mode 100644 index 0000000..a97ebe5 --- /dev/null +++ b/src/GPUAccelerators/6_ParallelExecutionOnGPUDevices.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7b6ab5e9-4f99-42b7-bbdf-7a5b98634513", + "metadata": {}, + "source": [ + "# Parallel Execution on GPU Devices\n", + "\n", + "OpenMP provides directives for parallel execution on GPU devices, allowing programmers to efficiently distribute work across multiple threads and teams. The `teams` and `distribute` directives are key constructs for achieving parallel execution on GPUs. In this section, we will explore the `teams` directive for SPMD (Single Program, Multiple Data) parallelism, the `distribute` directive for work sharing, and how to combine these directives for optimal performance.\n", + "\n", + "## teams directive for SPMD parallelism\n", + "\n", + "The `teams` directive is used to create a league of thread teams, where each team executes the structured block associated with the directive. This allows for SPMD parallelism, where each team executes the same code but operates on different data.\n", + "\n", + "The syntax of the `teams` directive is as follows:\n", + "\n", + "```c\n", + "#pragma omp teams [clause[[,] clause]...]\n", + "structured-block\n", + "```\n", + "\n", + "The `teams` directive supports clauses such as `num_teams` and `thread_limit` to control the number of teams and the maximum number of threads per team, respectively.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams map(to: a[0:n]) map(from: b[0:n])\n", + "{\n", + " #pragma omp parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " b[i] = a[i] * 2;\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `teams` directive creates a league of thread teams, and each team executes the parallel loop inside the structured block. The `parallel` directive is used to distribute the loop iterations among the threads within each team.\n", + "\n", + "## distribute directive for work sharing\n", + "\n", + "The `distribute` directive is used to distribute loop iterations across the master threads of the teams created by the `teams` directive. It provides a way to share work among the teams and achieve parallelism at the team level.\n", + "\n", + "The syntax of the `distribute` directive is as follows:\n", + "\n", + "```c\n", + "#pragma omp distribute [clause[[,] clause]...]\n", + "for-loops\n", + "```\n", + "\n", + "The `distribute` directive supports clauses such as `private`, `firstprivate`, `lastprivate`, and `collapse` to control data sharing and loop collapsing.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams distribute map(to: a[0:n]) map(from: b[0:n])\n", + "for (int i = 0; i < n; i++) {\n", + " b[i] = a[i] * 2;\n", + "}\n", + "```\n", + "\n", + "In this example, the `distribute` directive distributes the loop iterations across the master threads of the teams. Each team operates on a different portion of the input and output arrays.\n", + "\n", + "## Combining teams and distribute directives\n", + "\n", + "The `teams` and `distribute` directives can be combined to achieve multi-level parallelism on GPU devices. The `teams` directive creates a league of thread teams, and the `distribute` directive distributes the work among the teams. Additionally, the `parallel` directive can be used within each team to further parallelize the work among the threads within a team.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams distribute map(to: a[0:n]) map(from: b[0:n])\n", + "for (int i = 0; i < n; i++) {\n", + " #pragma omp parallel for\n", + " for (int j = 0; j < m; j++) {\n", + " b[i] += a[i * m + j];\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `teams` and `distribute` directives are combined to distribute the outer loop iterations across the teams. Within each team, the `parallel` directive is used to parallelize the inner loop iterations among the threads.\n", + "\n", + "## Nested parallelism with teams and parallel directives\n", + "\n", + "OpenMP supports nested parallelism, where parallel regions can be nested within each other. The `teams` directive can be combined with the `parallel` directive to achieve nested parallelism on GPU devices.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams map(to: a[0:n][0:m]) map(from: b[0:n])\n", + "{\n", + " #pragma omp distribute\n", + " for (int i = 0; i < n; i++) {\n", + " #pragma omp parallel for reduction(+:b[i])\n", + " for (int j = 0; j < m; j++) {\n", + " b[i] += a[i][j];\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `teams` directive creates a league of thread teams, and the `distribute` directive distributes the outer loop iterations across the teams. Within each team, the `parallel` directive is used to parallelize the inner loop iterations among the threads, and a reduction is performed to compute the sum of elements in each row of the input array.\n", + "\n", + "By using the `teams` and `distribute` directives, along with the `parallel` directive for nested parallelism, programmers can effectively parallelize their code and utilize the full potential of GPU devices.\n", + "\n", + "In the next section, we will discuss techniques for tuning the performance of GPU-offloaded code, including choosing the optimal number of teams and threads, optimizing data transfers and memory usage, and leveraging device-specific features." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28e9060e-071a-444e-bf84-cfe9007ab263", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/7_TuningPerformanceForGPUOffloading.ipynb b/src/GPUAccelerators/7_TuningPerformanceForGPUOffloading.ipynb new file mode 100644 index 0000000..d4522c8 --- /dev/null +++ b/src/GPUAccelerators/7_TuningPerformanceForGPUOffloading.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf774897-c7f1-468e-97c3-82334472ff64", + "metadata": {}, + "source": [ + "# Tuning Performance for GPU Offloading\n", + "\n", + "Achieving optimal performance when offloading computations to GPU devices requires careful tuning and consideration of various factors. In this section, we will explore techniques for choosing the right number of teams and threads, optimizing data transfers and memory usage, leveraging device-specific features, and measuring and profiling GPU performance.\n", + "\n", + "## Choosing the right number of teams and threads\n", + "\n", + "Selecting the appropriate number of teams and threads per team is crucial for maximizing the performance of GPU-offloaded code. The optimal configuration depends on factors such as the device architecture, the problem size, and the nature of the computation.\n", + "\n", + "Some guidelines for choosing the number of teams and threads include:\n", + "\n", + "- Match the number of teams to the number of streaming multiprocessors (SMs) on the GPU device. Each SM can execute one or more teams concurrently.\n", + "- Adjust the number of threads per team based on the register and shared memory usage of each thread. Higher thread counts may lead to resource contention, while lower thread counts may underutilize the device.\n", + "- Experiment with different combinations of teams and threads to find the sweet spot for your specific application.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams num_teams(64) thread_limit(128) map(to: a[0:n]) map(from: b[0:n])\n", + "{\n", + " // Parallel computation using 64 teams and up to 128 threads per team\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "In this example, the `num_teams` and `thread_limit` clauses are used to specify the number of teams and the maximum number of threads per team, respectively. Adjusting these values based on the device capabilities and the problem characteristics can help optimize performance.\n", + "\n", + "## Optimizing data transfers and memory usage\n", + "\n", + "Minimizing data transfers between the host and the device is critical for achieving high performance in GPU-offloaded code. Some strategies for optimizing data transfers and memory usage include:\n", + "\n", + "- Transfer only the necessary data to the device and keep it on the device as long as possible to avoid redundant transfers.\n", + "- Use the `target data` directive to create a data region that persists across multiple target regions, reducing the overhead of data transfers.\n", + "- Optimize memory access patterns to ensure coalesced memory accesses and minimize memory bandwidth bottlenecks.\n", + "- Utilize shared memory and registers on the device to reduce global memory accesses and improve data locality.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target data map(to: a[0:n], b[0:n]) map(from: c[0:n])\n", + "{\n", + " #pragma omp target teams distribute parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] = a[i] + b[i];\n", + " }\n", + "\n", + " // Reuse the mapped data for another computation\n", + " #pragma omp target teams distribute parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " c[i] *= 2;\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, the `target data` directive is used to create a data region that persists across multiple target regions. The input arrays `a` and `b` are mapped to the device once and reused for multiple computations, reducing the overhead of data transfers.\n", + "\n", + "## Leveraging device-specific features\n", + "\n", + "Different GPU devices have specific hardware features and capabilities that can be leveraged to optimize performance. Some device-specific features to consider include:\n", + "\n", + "- Using SIMD (Single Instruction, Multiple Data) instructions to exploit data parallelism within each thread.\n", + "- Utilizing device-specific memory hierarchies, such as texture memory or constant memory, for read-only data or frequently accessed data.\n", + "- Exploiting device-specific atomic operations and intrinsics for efficient synchronization and communication between threads.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams distribute parallel for simd\n", + "for (int i = 0; i < n; i++) {\n", + " // SIMD computation\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "In this example, the `simd` clause is used in combination with the `teams distribute parallel for` directive to enable SIMD parallelism within each thread. This allows the compiler to generate device-specific SIMD instructions to exploit data parallelism and improve performance.\n", + "\n", + "## Measuring and profiling GPU performance\n", + "\n", + "Measuring and profiling the performance of GPU-offloaded code is essential for identifying performance bottlenecks, guiding optimization efforts, and assessing the effectiveness of tuning strategies. Some techniques for measuring and profiling GPU performance include:\n", + "\n", + "- Using OpenMP runtime functions such as `omp_get_wtime()` to measure the execution time of specific code regions.\n", + "- Utilizing vendor-specific profiling tools, such as NVIDIA Visual Profiler or AMD ROCm Profiler, to analyze GPU performance metrics and identify performance issues.\n", + "- Employing hardware performance counters to gather low-level performance data, such as memory bandwidth utilization or cache hit rates.\n", + "\n", + "Example:\n", + "```c\n", + "double start = omp_get_wtime();\n", + "\n", + "#pragma omp target teams distribute parallel for\n", + "for (int i = 0; i < n; i++) {\n", + " // Computation to be profiled\n", + " // ...\n", + "}\n", + "\n", + "double end = omp_get_wtime();\n", + "double elapsed = end - start;\n", + "printf(\"Elapsed time: %f seconds\\n\", elapsed);\n", + "```\n", + "\n", + "In this example, the `omp_get_wtime()` function is used to measure the execution time of the target region. By profiling and analyzing the performance of different code regions, programmers can identify performance bottlenecks and make informed decisions about optimization strategies.\n", + "\n", + "Tuning the performance of GPU-offloaded code requires an iterative process of experimentation, measurement, and optimization. By choosing the right number of teams and threads, optimizing data transfers and memory usage, leveraging device-specific features, and utilizing profiling tools, programmers can unlock the full performance potential of GPU devices using OpenMP.\n", + "\n", + "In the next section, we will discuss advanced topics and best practices for GPU offloading with OpenMP, including the Unified Shared Memory (USM) model, interoperability with other GPU programming models, debugging and error handling, and performance portability considerations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4921efe0-47a1-494f-9a2d-89f4db45d643", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/8_AdvancedTopicsAndBestPractices.ipynb b/src/GPUAccelerators/8_AdvancedTopicsAndBestPractices.ipynb new file mode 100644 index 0000000..5ae84e4 --- /dev/null +++ b/src/GPUAccelerators/8_AdvancedTopicsAndBestPractices.ipynb @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf774897-c7f1-468e-97c3-82334472ff64", + "metadata": {}, + "source": [ + "# Advanced Topics and Best Practices\n", + "\n", + "In this section, we will explore advanced topics and best practices for GPU offloading with OpenMP. We will discuss the Unified Shared Memory (USM) model, interoperability with other GPU programming models like CUDA, debugging and error handling techniques, and performance portability considerations.\n", + "\n", + "## Unified Shared Memory (USM) model\n", + "\n", + "OpenMP 5.0 introduced the Unified Shared Memory (USM) model, which provides a unified view of memory across the host and device. USM simplifies memory management and enables more flexible data sharing between the host and device.\n", + "\n", + "There are three types of USM allocations:\n", + "\n", + "- Device allocations: Memory is allocated on the device and can only be accessed by the device.\n", + "- Host allocations: Memory is allocated on the host and can be accessed by both the host and device.\n", + "- Shared allocations: Memory is accessible by both the host and device, with the allocation being managed by the runtime.\n", + "\n", + "Example:\n", + "```c\n", + "int* shared_data = omp_target_alloc_shared(n * sizeof(int), omp_get_default_device());\n", + "\n", + "#pragma omp target teams distribute parallel for\n", + "for (int i = 0; i < n; i++) {\n", + " shared_data[i] = i;\n", + "}\n", + "\n", + "// Access shared_data on the host\n", + "for (int i = 0; i < n; i++) {\n", + " printf(\"%d \", shared_data[i]);\n", + "}\n", + "\n", + "omp_target_free(shared_data, omp_get_default_device());\n", + "```\n", + "\n", + "In this example, `omp_target_alloc_shared` is used to allocate shared memory that is accessible by both the host and device. The device modifies the shared data, and the host can directly access it without explicit data transfers.\n", + "\n", + "## Interoperability with CUDA and other GPU programming models\n", + "\n", + "OpenMP can interoperate with other GPU programming models, such as CUDA, to leverage existing code or libraries. OpenMP provides mechanisms to integrate with CUDA code and perform seamless data sharing between OpenMP and CUDA.\n", + "\n", + "Example:\n", + "```c\n", + "// CUDA kernel\n", + "__global__ void cuda_kernel(int* data, int n) {\n", + " int idx = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (idx < n) {\n", + " data[idx] *= 2;\n", + " }\n", + "}\n", + "\n", + "// OpenMP target region\n", + "#pragma omp target data map(tofrom: data[0:n])\n", + "{\n", + " // Launch CUDA kernel\n", + " cuda_kernel<<<(n + 255) / 256, 256>>>(data, n);\n", + "\n", + " // OpenMP parallel loop\n", + " #pragma omp target teams distribute parallel for\n", + " for (int i = 0; i < n; i++) {\n", + " data[i] += 1;\n", + " }\n", + "}\n", + "```\n", + "\n", + "In this example, a CUDA kernel is launched within an OpenMP target data region. The data is mapped between the host and device using the `map` clause, allowing both the CUDA kernel and the OpenMP parallel loop to operate on the same data.\n", + "\n", + "## Debugging and error handling for GPU offloading\n", + "\n", + "Debugging GPU-offloaded code can be challenging due to the separate execution on the device. OpenMP provides several techniques and best practices for debugging and error handling:\n", + "\n", + "- Use the `omp_set_default_device` function to specify the device for debugging purposes.\n", + "- Employ conditional compilation or runtime checks to execute device code on the host for easier debugging.\n", + "- Utilize device-specific debugging tools, such as NVIDIA CUDA-GDB or AMD ROCm GDB, to debug GPU code directly.\n", + "- Implement robust error handling mechanisms to detect and handle errors that may occur during GPU execution.\n", + "\n", + "Example:\n", + "```c\n", + "#pragma omp target teams distribute parallel for\n", + "for (int i = 0; i < n; i++) {\n", + " if (data[i] < 0) {\n", + " #pragma omp critical\n", + " {\n", + " fprintf(stderr, \"Error: Negative value encountered at index %d\\n\", i);\n", + " }\n", + " #pragma omp cancel teams\n", + " }\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "In this example, error handling is implemented within the target region. If a negative value is encountered in the `data` array, an error message is printed, and the `cancel` directive is used to abort the execution of the target region.\n", + "\n", + "8.4 Performance portability considerations\n", + "\n", + "Performance portability is an important aspect of GPU offloading, as it ensures that the code can run efficiently across different GPU architectures and systems. Some considerations for performance portability include:\n", + "\n", + "- Use OpenMP directives and clauses that are supported across different compilers and platforms.\n", + "- Avoid device-specific optimizations that may hinder portability.\n", + "- Employ runtime checks and device-specific code paths to adapt to different GPU capabilities.\n", + "- Utilize OpenMP's device-specific functions and environment variables to query device information and adjust execution parameters accordingly.\n", + "\n", + "Example:\n", + "```c\n", + "#ifdef _OPENMP\n", + " int max_teams = omp_get_max_teams();\n", + " int max_threads = omp_get_max_threads();\n", + "#else\n", + " int max_teams = 64;\n", + " int max_threads = 128;\n", + "#endif\n", + "\n", + "#pragma omp target teams num_teams(max_teams) thread_limit(max_threads)\n", + "{\n", + " // ...\n", + "}\n", + "```\n", + "\n", + "In this example, the number of teams and threads per team is adjusted based on the device capabilities using OpenMP's runtime functions. This allows the code to adapt to different devices and achieve better performance portability.\n", + "\n", + "By leveraging advanced features like USM, interoperability with other GPU programming models, debugging techniques, and considering performance portability, programmers can write efficient and portable GPU-offloaded code using OpenMP." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4921efe0-47a1-494f-9a2d-89f4db45d643", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/GPUAccelerators/9_Conclusion.ipynb b/src/GPUAccelerators/9_Conclusion.ipynb new file mode 100644 index 0000000..b5e2ce6 --- /dev/null +++ b/src/GPUAccelerators/9_Conclusion.ipynb @@ -0,0 +1,59 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bf774897-c7f1-468e-97c3-82334472ff64", + "metadata": {}, + "source": [ + "# Conclusion\n", + "\n", + "In this chapter, we explored the powerful features and techniques for parallel programming on GPU accelerators using OpenMP. We discussed the key device constructs, such as `target`, `target data`, `target update`, and `target enter/exit data`, which enable offloading computations to GPU devices.\n", + "\n", + "We delved into the intricacies of mapping data between the host and device, including the `map` clause, implicit and explicit data mapping, array shaping, pointer mapping, and mapping structured data types. These techniques allow programmers to efficiently manage data transfers and optimize memory usage.\n", + "\n", + "We also covered asynchronous execution and dependencies using the `nowait` clause, `depend` clause, and `taskwait` directive, enabling overlapping of computation and data transfers and specifying dependencies between tasks and target regions.\n", + "\n", + "Device memory management was discussed, including OpenMP's device memory routines, memory allocation and deallocation, host-device memory association, and techniques for optimizing data transfers.\n", + "\n", + "We explored parallel execution on GPU devices using the `teams` and `distribute` directives, and how to combine them for efficient work distribution and parallelization.\n", + "\n", + "Performance tuning techniques were presented, including choosing the right number of teams and threads, optimizing data transfers and memory usage, leveraging device-specific features, and measuring and profiling GPU performance.\n", + "\n", + "Finally, we touched upon advanced topics and best practices, such as the Unified Shared Memory (USM) model, interoperability with other GPU programming models, debugging and error handling, and performance portability considerations.\n", + "\n", + "OpenMP provides a comprehensive and portable solution for parallel programming on GPU accelerators. By leveraging the directives, clauses, and runtime functions discussed in this chapter, programmers can harness the power of GPU devices to accelerate their applications and achieve significant performance gains.\n", + "\n", + "As GPU architectures and programming models continue to evolve, OpenMP remains at the forefront, providing a high-level and productive approach to GPU offloading. With its ongoing development and community support, OpenMP is well-positioned to meet the challenges and opportunities of parallel programming on GPU accelerators in the future." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4921efe0-47a1-494f-9a2d-89f4db45d643", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9a32a525a4e5a52b56ab9659c96136793499e165 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Fri, 21 Jun 2024 00:00:23 -0700 Subject: [PATCH 72/91] Use the new repo name in the config --- README.md | 2 +- src/_config.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index be80abe..77201c8 100644 --- a/README.md +++ b/README.md @@ -1 +1 @@ -# OpenMPProgrammingBook \ No newline at end of file +# InteractiveOpenMPProgramming diff --git a/src/_config.yml b/src/_config.yml index aae182d..3aaf0fb 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -25,7 +25,7 @@ bibtex_bibfiles: # Information about where the book exists on the web repository: - url: https://github.com/passlab/OpenMPProgrammingBook # Online location of your book + url: https://github.com/passlab/InteractiveOpenMPProgramming # Online location of your book path_to_book: src # Optional path to your book, relative to the repository root branch: main # Which branch of the repository should be used when creating links (optional) From a55bc9a44cf02dd53e739d219920d362bfe8fed2 Mon Sep 17 00:00:00 2001 From: Anjia Wang Date: Fri, 21 Jun 2024 00:06:44 -0700 Subject: [PATCH 73/91] Update book title --- src/cover.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cover.md b/src/cover.md index ddc8c4c..90fd8de 100644 --- a/src/cover.md +++ b/src/cover.md @@ -1,5 +1,5 @@ -# OpenMP Programming Book +# Interactive OpenMP Programming ====================================== -Authors: \ No newline at end of file +Authors: From 1b021db93b13437ddef7070e9020804d2cd29f78 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 2 Jul 2024 16:29:51 -0400 Subject: [PATCH 74/91] Added the cover --- src/cover.md | 71 +++++++++++++++++++++++++++++++++++++++++-- src/cover_figure.png | Bin 0 -> 707654 bytes 2 files changed, 68 insertions(+), 3 deletions(-) create mode 100644 src/cover_figure.png diff --git a/src/cover.md b/src/cover.md index 90fd8de..25dbd60 100644 --- a/src/cover.md +++ b/src/cover.md @@ -1,5 +1,70 @@ -# Interactive OpenMP Programming +--- +title: "Interactive OpenMP Programming Book" +authors: + - name: "Xinyao Yi" + email: "xyi2@uncc.edu" + institution: "University of North Carolina at Charlotte" + - name: "Anjia Wang" + email: "anjia.wang@intel.com" + institution: "Intel Corporation" + - name: "Yonghong Yan" + email: "yyan7@uncc.edu" + institution: "University of North Carolina at Charlotte" + - name: "Chunhua Liao" + email: "liao6@llnl.gov" + institution: "Lawrence Livermore National Laboratory" +publication_date: "2024" +book_version: "1.0" +license: "CC BY-NC-ND 4.0" +--- -====================================== +# Interactive OpenMP Programming Book + +![Cover Image](cover_figure.png) + +**Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan, Chunhua Liao + +**Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu, liao6@llnl.gov + +**Institutions:** University of North Carolina at Charlotte, Lawrence Livermore National Laboratory +**Publication Date:** 2024 + + + +--- + +## About the Book + +**Interactive OpenMP Programming Book** pioneers the integration of Large Language Models (LLMs) such as Gemini Pro 1.5, Claude 3, and ChatGPT-4 into the educational fabric of high-performance computing. This textbook revolutionizes learning by combining cutting-edge AI with traditional educational methodologies to offer a dynamic, interactive experience through Jupyter Books. It enables code execution directly from the web browser, enhancing the learning process with real-time feedback. + +## Key Features + +- **Interactive Examples:** Each chapter includes practical programming examples that readers can execute directly within the book. +- **Expert Insights and AI Integration:** Learn high-performance computing through a seamless blend of expert knowledge and AI-generated content, ensuring both depth and pedagogical effectiveness. +- **Up-to-Date Content:** Continuously updated with the latest OpenMP specifications to provide the most current learning experience. +- **Open Source and Accessible:** Freely available online, reducing barriers to access and enabling a wider dissemination of knowledge. + +## Target Audience + +This book is designed for students, educators, and professionals in the field of computing who are interested in advancing their understanding of parallel programming using OpenMP. + +## Available Online For Free + +Available online for free at https://passlab.github.io/InteractiveOpenMPProgramming/cover.html, this book aims to be accessible to anyone interested in the field of high-performance computing. + +## Disclaimer +The authors have made every effort to ensure that the information in this book is correct at the time of publication. The code and content are provided for instructional purposes only. The authors do not offer any warranties and expressly disclaim any liability for errors or omissions, whether such errors or omissions result from negligence, accident, or any other cause. + + + +--- +**Book Version:** Interactive OpenMP Programming Book — Version 1.0 + +**Copyright:** © 2024 Xinyao Yi et al. All rights reserved. + +**License:** CC BY-NC-ND 4.0 +This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. + +--- +## Acknowledgements -Authors: diff --git a/src/cover_figure.png b/src/cover_figure.png new file mode 100644 index 0000000000000000000000000000000000000000..21b70d6b52a5db2ce809d3ae15a7de38784d885f GIT binary patch literal 707654 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    sRSpdiB*l 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

    U&Y)4Tdh`B&|ZH%twZEjssA(ZQII# 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vGdRr>9-Y)WZ|9=uXs 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 z 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 A>Hq)$ literal 0 HcmV?d00001 From c934f416ab20b10676e372f4e5ca1f845f6827d1 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 2 Jul 2024 16:33:48 -0400 Subject: [PATCH 75/91] Put the figure at the top of cover --- src/cover.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/cover.md b/src/cover.md index 25dbd60..9852194 100644 --- a/src/cover.md +++ b/src/cover.md @@ -17,10 +17,11 @@ publication_date: "2024" book_version: "1.0" license: "CC BY-NC-ND 4.0" --- +![Cover Image](cover_figure.png) # Interactive OpenMP Programming Book -![Cover Image](cover_figure.png) + **Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan, Chunhua Liao From 9d4bba56c84c46d9121bad3dbeb444e1d52af091 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 2 Jul 2024 16:47:38 -0400 Subject: [PATCH 76/91] Added Non-Commercial Use Declaration --- src/_toc.yml | 3 --- src/book_intro.md | 2 -- src/copyright.md | 3 --- src/cover.md | 4 +++- src/preface.md | 2 -- 5 files changed, 3 insertions(+), 11 deletions(-) delete mode 100644 src/book_intro.md delete mode 100644 src/copyright.md delete mode 100644 src/preface.md diff --git a/src/_toc.yml b/src/_toc.yml index 74466f1..e2a2c40 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -5,10 +5,7 @@ format: jb-book root: cover parts: - chapters: - - file: copyright - - file: book_intro - file: foreword - - file: preface - numbered: True chapters: - file: Ch1_OpenmpIntro diff --git a/src/book_intro.md b/src/book_intro.md deleted file mode 100644 index bbe83b2..0000000 --- a/src/book_intro.md +++ /dev/null @@ -1,2 +0,0 @@ -# Introduction -This is a brief introduction to give you a feel for how book content is structured. diff --git a/src/copyright.md b/src/copyright.md deleted file mode 100644 index aa8a154..0000000 --- a/src/copyright.md +++ /dev/null @@ -1,3 +0,0 @@ -# copyright -Here is the publication information. -For example, when published? the copyright? funding? \ No newline at end of file diff --git a/src/cover.md b/src/cover.md index 9852194..8309fe1 100644 --- a/src/cover.md +++ b/src/cover.md @@ -64,7 +64,9 @@ The authors have made every effort to ensure that the information in this book i **Copyright:** © 2024 Xinyao Yi et al. All rights reserved. **License:** CC BY-NC-ND 4.0 -This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. +This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License[https://creativecommons.org/licenses/by-nc-nd/4.0/deed.en]. + +**Non-Commercial Use Declaration:** This publication is strictly for educational and scholarly use and is not intended for sale or any form of commercial profit. Any reproduction, adaptation, distribution, or public display of the contents of this book must adhere to the terms set forth by the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. This restriction includes all media, digital or otherwise, and is enforceable under applicable copyright laws. --- ## Acknowledgements diff --git a/src/preface.md b/src/preface.md deleted file mode 100644 index d4a9d9e..0000000 --- a/src/preface.md +++ /dev/null @@ -1,2 +0,0 @@ -# preface -This is preface from the author \ No newline at end of file From 2d7eb5566083cab2fb0d018d2c31ceb87d35f74e Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 2 Jul 2024 17:15:25 -0400 Subject: [PATCH 77/91] Added the preface. There is one acknowledgement in the preface and another one in the cover. Check this with Dr. Yan --- src/cover.md | 2 +- src/foreword.md | 41 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 40 insertions(+), 3 deletions(-) diff --git a/src/cover.md b/src/cover.md index 8309fe1..7b1670d 100644 --- a/src/cover.md +++ b/src/cover.md @@ -70,4 +70,4 @@ This work is licensed under the Creative Commons Attribution-NonCommercial-NoDer --- ## Acknowledgements - +Put the sponsorship here. \ No newline at end of file diff --git a/src/foreword.md b/src/foreword.md index ca079cb..17a6ab7 100644 --- a/src/foreword.md +++ b/src/foreword.md @@ -1,3 +1,40 @@ -# foreword +# Preface -This is foreword from other people. \ No newline at end of file +Welcome to the "Interactive OpenMP Programming Book," a pioneering educational resource that merges high-performance computing (HPC) education with advanced artificial intelligence (AI) technologies. It aims to address the growing educational demands in parallel computing, particularly within the OpenMP framework used across multi-core and multi-threaded processors. + +## Motivation + +The impetus for this book stems from two primary needs. First, the rapid evolution of OpenMP specifications has necessitated an educational resource that not only keeps pace with technological advancements but also incorporates the interactivity essential for effective learning. Traditional resources often fall short in updating content and integrating interactive elements, which are critical for engaging modern learners. + +Second, this book explores the potential of integrating Large Language Models (LLMs) such as Gemini Pro 1.5, Claude 3, and ChatGPT-4 in educational content creation. These AI tools expedite the initial drafting of educational materials. However, to ensure depth and accuracy, extensive manual revisions and expert insights were indispensable. This iterative process ensures that the final content is both pedagogically effective and technically accurate. + +## Features + +Designed within the Jupyter Book framework, this book facilitates an interactive learning experience by allowing code execution directly from the web browser. This real-time interaction not only engages readers but also solidifies their understanding through practice. The structure of the book is crafted to provide foundational knowledge before advancing to more complex topics, enabling a gradual and comprehensive learning curve. + +## Structure and Content + +The "Interactive OpenMP Programming Book" is structured to facilitate a progressive learning journey from basic to advanced topics across several key areas: + +- **Overview of OpenMP Programming**: Introduces OpenMP, from basic parallel programming constructs to performance analysis techniques. +- **Parallel Programming for Multicore and Multi-CPU Machines**: Dives into strategies and techniques for effective parallelism on shared memory systems using OpenMP. +- **Parallel Programming for SIMD and Vector Architecture**: Covers SIMD and vectorization within OpenMP to enhance computational efficiency and speed. +- **Parallel Programming for GPU Accelerators**: Explores GPU programming using OpenMP, from basic device management to complex performance tuning and best practices. + +Each chapter integrates theoretical knowledge with practical exercises, supported by interactive Jupyter notebooks that allow readers to execute code and see real-time results. + +## How to Use This Book + +- **Students** can build foundational skills, progressing to more complex topics as their understanding deepens. +- **Educators** can use this book as a curriculum resource, providing students with interactive content that complements theoretical lectures. +- **Professionals** in the field of HPC will find advanced topics and performance optimization techniques to enhance their project outcomes. + +## Acknowledgements + +We extend our heartfelt gratitude to the community of peer reviewers and the early adopters of our manuscript, whose rigorous feedback and insightful comments have been crucial in shaping this resource. Their contributions have ensured that the book not only meets but exceeds the educational standards required for both novice and experienced programmers. + +## Invitation to Readers + +We invite educators, students, and professionals to explore the "Interactive OpenMP Programming Book." This resource is more than just a textbook; it is a platform for innovation in the way we teach and learn parallel programming. By using this book, we hope you will discover not only the technical intricacies of OpenMP but also the potential of AI to transform educational methodologies in computing. + +Enjoy your exploration through the rich landscape of high-performance computing, made accessible and engaging through this interactive book. From 175f0d23d4f0b4bdeee7667809e6e91ed9b55f53 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 3 Jul 2024 12:07:18 -0400 Subject: [PATCH 78/91] Changed the config.yml to add the author names --- src/_config.yml | 4 ++-- src/foreword.md | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/_config.yml b/src/_config.yml index 3aaf0fb..e121016 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -1,8 +1,8 @@ # Book settings # Learn more at https://jupyterbook.org/customize/config.html -title: Parallel Programming and Performance Optimization With OpenMP -author: Xinyao Yi, Anjia Wang, and Yonghong Yan +title: Interactive OpenMP Programming Book +author: Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao logo: logo.png # Force re-execution of notebooks on each build. diff --git a/src/foreword.md b/src/foreword.md index 17a6ab7..6d26eac 100644 --- a/src/foreword.md +++ b/src/foreword.md @@ -2,8 +2,6 @@ Welcome to the "Interactive OpenMP Programming Book," a pioneering educational resource that merges high-performance computing (HPC) education with advanced artificial intelligence (AI) technologies. It aims to address the growing educational demands in parallel computing, particularly within the OpenMP framework used across multi-core and multi-threaded processors. -## Motivation - The impetus for this book stems from two primary needs. First, the rapid evolution of OpenMP specifications has necessitated an educational resource that not only keeps pace with technological advancements but also incorporates the interactivity essential for effective learning. Traditional resources often fall short in updating content and integrating interactive elements, which are critical for engaging modern learners. Second, this book explores the potential of integrating Large Language Models (LLMs) such as Gemini Pro 1.5, Claude 3, and ChatGPT-4 in educational content creation. These AI tools expedite the initial drafting of educational materials. However, to ensure depth and accuracy, extensive manual revisions and expert insights were indispensable. This iterative process ensures that the final content is both pedagogically effective and technically accurate. From 503dfc5be04f817b0e48fe9f7d59abab2a22b224 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 3 Jul 2024 12:50:00 -0400 Subject: [PATCH 79/91] Added the copyright in the footage and added the sponsorship --- src/_config.yml | 1 + src/cover.md | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/_config.yml b/src/_config.yml index e121016..9ec7bd4 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -3,6 +3,7 @@ title: Interactive OpenMP Programming Book author: Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao +copyright: "2024" logo: logo.png # Force re-execution of notebooks on each build. diff --git a/src/cover.md b/src/cover.md index 7b1670d..ee32026 100644 --- a/src/cover.md +++ b/src/cover.md @@ -70,4 +70,4 @@ This work is licensed under the Creative Commons Attribution-NonCommercial-NoDer --- ## Acknowledgements -Put the sponsorship here. \ No newline at end of file +Funding for this research and development was provided by the National Science Foundation under award number CISE SHF-1551182 and CISE SHF-2015254. \ No newline at end of file From ac328302a4e260aeeec1d13261fd1e9e3023d4fb Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 3 Jul 2024 13:13:48 -0400 Subject: [PATCH 80/91] Added the preface for each chapter --- src/Ch1_OpenmpIntro.md | 8 ++++++++ src/Ch2_MulticoreMultiCPU.md | 5 +---- src/Ch3_SIMDVector.md | 2 +- src/Ch4_GPUAccel.md | 4 ++-- 4 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/Ch1_OpenmpIntro.md b/src/Ch1_OpenmpIntro.md index aaa485a..0e94c05 100644 --- a/src/Ch1_OpenmpIntro.md +++ b/src/Ch1_OpenmpIntro.md @@ -1 +1,9 @@ # Overview of OpenMP Programming + +Moore's Law originally stated that the number of transistors on a microchip doubles approximately every two years, leading to a corresponding increase in computational power and frequency. This rapid advancement was achievable by increasing transistor density. However, as transistor density increased, so did the heat generated, making it increasingly difficult to maintain this pace of improvement. + +To address this challenge, computer architects sought alternative solutions. One effective and cost-efficient strategy was the implementation of multiple cores within a single CPU. IBM was a pioneer in this area, releasing the first multi-core CPU in 2001. Intel followed in 2002 with the Intel Pentium 4, which introduced hyper-threading. Hyper-threading allowed the processor to switch between tasks quickly, creating the illusion of performing multiple processes simultaneously, though it wasn't true parallel computing. + +Since then, the adoption of multi-core CPUs has become widespread, with some systems incorporating multiple CPUs. This shift necessitated the development of methods to effectively utilize these additional cores, leading to the rise of parallel computing. + +OpenMP (Open Multi-Processing) is a powerful and versatile API that simplifies parallel programming for a variety of computing architectures, including shared memory systems, distributed memory systems, and accelerators such as GPUs. This chapter introduces the fundamental concepts of OpenMP, including its key features, and basic syntax. You will learn how to set up your development environment, write your first parallel program, and understand the core constructs that make OpenMP an indispensable tool for enhancing computational performance. Through interactive examples, you will gain a solid foundation in parallel programming principles and prepare yourself for more advanced topics in subsequent chapters. \ No newline at end of file diff --git a/src/Ch2_MulticoreMultiCPU.md b/src/Ch2_MulticoreMultiCPU.md index c981a47..a5e9644 100644 --- a/src/Ch2_MulticoreMultiCPU.md +++ b/src/Ch2_MulticoreMultiCPU.md @@ -1,6 +1,3 @@ # Parallel Programming for Multicore and Multi-CPU Machines -Moores's Law states CPUs double in frequency every two years. This was possible by increasing the transistor density. As time has gone on this has proven to be more difficult because with more transistors more heat is produced. As this problem became more apparent Computer Architects turned to another solution, a cheaper yet effective solution. Which was the implementation of multiple cores within a CPU. IBM was the first to release a Multi-core CPU back in 2001. Intel’s attempt to release processors of this caliber came in 2002 with the Intel Pentium 4. This processor didn’t implement parallel computing more or less just hyperthreading. This allowed it to switch between programs really fast so it gave the appearance of doing multiple processes at once. Since then more and more computers have been implementing multicore CPUs, some even have multiple CPUs. Because of this computer scientists needed to find a way to utilize these extra cores, thus was the birth of parallel computing. - -In this book, we will be discussing multicore and multi CPU machines and how they work, how to use them, and how to optimize your code to use them effectively. - +With the proliferation of multicore and multi-CPU systems, efficiently distributing computational tasks across multiple processing units has become essential. This chapter delves into the techniques and strategies for parallel programming on multicore and multi-CPU machines using OpenMP. You will explore thread management, data sharing, and synchronization mechanisms to ensure your programs run efficiently and correctly. Interactive exercises will guide you through real-world scenarios, helping you understand how to maximize the performance of your applications on multicore architectures. \ No newline at end of file diff --git a/src/Ch3_SIMDVector.md b/src/Ch3_SIMDVector.md index 44fa7b8..a69b570 100644 --- a/src/Ch3_SIMDVector.md +++ b/src/Ch3_SIMDVector.md @@ -1,4 +1,4 @@ Parallel Programming for SIMD and Vector Architecture ===================================================== -Temporary page indicating start of a section +Single Instruction, Multiple Data (SIMD) and vector architectures offer significant performance gains by allowing the simultaneous execution of operations across multiple data points. In this chapter, we will explore how OpenMP can be used to harness the power of SIMD and vectorization. You will learn about vector registers, alignment, and memory access patterns that impact performance. Through hands-on examples and exercises, you will practice optimizing your code to fully exploit SIMD capabilities, enabling you to achieve higher computational throughput and efficiency. \ No newline at end of file diff --git a/src/Ch4_GPUAccel.md b/src/Ch4_GPUAccel.md index 7abc9ea..2d1ac0b 100644 --- a/src/Ch4_GPUAccel.md +++ b/src/Ch4_GPUAccel.md @@ -1,4 +1,4 @@ Parallel Programming for GPU Accelerators ========================================= -GPUAccel -Temporary page indicating start of a section + +Graphics Processing Units (GPUs) have revolutionized parallel computing by providing massive computational power for a wide range of applications. This chapter focuses on leveraging OpenMP to program GPU accelerators, covering the concepts of offloading computations to GPUs and managing data transfers between the host CPU and the GPU. You will explore the OpenMP directives and clauses specifically designed for GPU programming, such as `target`, `teams`, and `distribute`, which facilitate the execution of parallel regions on the GPU. Additionally, you will delve into techniques for efficiently transferring data between the host and device, including strategies for minimizing data movement and optimizing memory usage to maximize performance. Through hands-on examples and exercises, you will gain practical experience in managing the complexities of CPU-GPU interaction. By the end of this chapter, you will be equipped with the knowledge and skills to accelerate your applications using GPUs, unlocking new levels of performance for your computational tasks. \ No newline at end of file From a8d700c04c0af31a73bd33d7080c30faf9710ae9 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Mon, 15 Jul 2024 12:19:55 -0400 Subject: [PATCH 81/91] Added the re-drawed figure for fork-join model --- src/Openmp_C/0_13209261094r4F.png | Bin 11310 -> 0 bytes src/Openmp_C/1_IntroductionOfOpenMP.ipynb | 5 ++--- src/Openmp_C/20190720101130709.png | Bin 65467 -> 0 bytes src/Openmp_C/fork_joint.png | Bin 0 -> 51189 bytes 4 files changed, 2 insertions(+), 3 deletions(-) delete mode 100644 src/Openmp_C/0_13209261094r4F.png delete mode 100644 src/Openmp_C/20190720101130709.png create mode 100644 src/Openmp_C/fork_joint.png diff --git a/src/Openmp_C/0_13209261094r4F.png b/src/Openmp_C/0_13209261094r4F.png deleted file mode 100644 index 1b7af26f83ea418ee269fae4f649b866e113f622..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 11310 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

  • +FmPxB8TQ|k(ILjy;46OzaR*+DDJGMt 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 diff --git a/src/Openmp_C/fork_joint.png b/src/Openmp_C/fork_joint.png new file mode 100644 index 0000000000000000000000000000000000000000..ad17876244fdacbb8dd88891ced7659fe8d8019b GIT binary patch literal 51189 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 literal 0 HcmV?d00001 From 9d3d9e22e32af91339594c43eabda1977f3a1f0b Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 17 Jul 2024 14:45:59 -0400 Subject: [PATCH 82/91] Remove ome author --- src/cover.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/cover.md b/src/cover.md index ee32026..1536a6f 100644 --- a/src/cover.md +++ b/src/cover.md @@ -10,9 +10,6 @@ authors: - name: "Yonghong Yan" email: "yyan7@uncc.edu" institution: "University of North Carolina at Charlotte" - - name: "Chunhua Liao" - email: "liao6@llnl.gov" - institution: "Lawrence Livermore National Laboratory" publication_date: "2024" book_version: "1.0" license: "CC BY-NC-ND 4.0" @@ -25,9 +22,9 @@ license: "CC BY-NC-ND 4.0" **Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan, Chunhua Liao -**Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu, liao6@llnl.gov +**Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu -**Institutions:** University of North Carolina at Charlotte, Lawrence Livermore National Laboratory +**Institutions:** University of North Carolina at Charlotte **Publication Date:** 2024 From 2cd165ba85b4a0fe89c491cb26a40db607cfbaab Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Wed, 17 Jul 2024 14:49:10 -0400 Subject: [PATCH 83/91] Fixed some errors --- src/_config.yml | 2 +- src/cover.md | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/_config.yml b/src/_config.yml index 9ec7bd4..5d09379 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -2,7 +2,7 @@ # Learn more at https://jupyterbook.org/customize/config.html title: Interactive OpenMP Programming Book -author: Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao +author: Xinyao Yi, Anjia Wang and Yonghong Yan copyright: "2024" logo: logo.png diff --git a/src/cover.md b/src/cover.md index 1536a6f..bd5a969 100644 --- a/src/cover.md +++ b/src/cover.md @@ -20,11 +20,12 @@ license: "CC BY-NC-ND 4.0" -**Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan, Chunhua Liao +**Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan **Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu **Institutions:** University of North Carolina at Charlotte + **Publication Date:** 2024 From c0b21e7389a662ef7473af8e36edd26f8c416e58 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Mon, 2 Sep 2024 23:38:20 -0400 Subject: [PATCH 84/91] Added Dr. Liao as one of the authors --- src/cover.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/cover.md b/src/cover.md index bd5a969..e4460bc 100644 --- a/src/cover.md +++ b/src/cover.md @@ -10,6 +10,9 @@ authors: - name: "Yonghong Yan" email: "yyan7@uncc.edu" institution: "University of North Carolina at Charlotte" + - name: "Chunhua Liao" + email: "liao6@llnl.gov" + institution: "Lawrence Livermore National Laboratory" publication_date: "2024" book_version: "1.0" license: "CC BY-NC-ND 4.0" @@ -20,11 +23,11 @@ license: "CC BY-NC-ND 4.0" -**Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan +**Authors:** Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao -**Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu +**Emails:** xyi2@uncc.edu, anjia.wang@intel.com, yyan7@uncc.edu and liao6@llnl.gov -**Institutions:** University of North Carolina at Charlotte +**Institutions:** University of North Carolina at Charlotte, Lawrence Livermore National Laboratory **Publication Date:** 2024 From 7eee1b80dd23f1b4ad063bae89791584050e34a2 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Tue, 3 Sep 2024 00:42:14 -0400 Subject: [PATCH 85/91] Added the author name at footpage --- src/_config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/_config.yml b/src/_config.yml index 5d09379..9ec7bd4 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -2,7 +2,7 @@ # Learn more at https://jupyterbook.org/customize/config.html title: Interactive OpenMP Programming Book -author: Xinyao Yi, Anjia Wang and Yonghong Yan +author: Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao copyright: "2024" logo: logo.png From 391ba160b090a83d1f9add1f789dcf00bd3e4539 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Fri, 13 Sep 2024 23:06:20 -0400 Subject: [PATCH 86/91] Changed the book name --- src/_config.yml | 2 +- src/cover.md | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/_config.yml b/src/_config.yml index 9ec7bd4..67bda96 100644 --- a/src/_config.yml +++ b/src/_config.yml @@ -1,7 +1,7 @@ # Book settings # Learn more at https://jupyterbook.org/customize/config.html -title: Interactive OpenMP Programming Book +title: Interactive OpenMP Programming author: Xinyao Yi, Anjia Wang, Yonghong Yan and Chunhua Liao copyright: "2024" logo: logo.png diff --git a/src/cover.md b/src/cover.md index e4460bc..a199d88 100644 --- a/src/cover.md +++ b/src/cover.md @@ -1,5 +1,5 @@ --- -title: "Interactive OpenMP Programming Book" +title: "Interactive OpenMP Programming" authors: - name: "Xinyao Yi" email: "xyi2@uncc.edu" @@ -19,7 +19,7 @@ license: "CC BY-NC-ND 4.0" --- ![Cover Image](cover_figure.png) -# Interactive OpenMP Programming Book +# Interactive OpenMP Programming @@ -37,7 +37,7 @@ license: "CC BY-NC-ND 4.0" ## About the Book -**Interactive OpenMP Programming Book** pioneers the integration of Large Language Models (LLMs) such as Gemini Pro 1.5, Claude 3, and ChatGPT-4 into the educational fabric of high-performance computing. This textbook revolutionizes learning by combining cutting-edge AI with traditional educational methodologies to offer a dynamic, interactive experience through Jupyter Books. It enables code execution directly from the web browser, enhancing the learning process with real-time feedback. +**Interactive OpenMP Programming** pioneers the integration of Large Language Models (LLMs) such as Gemini Pro 1.5, Claude 3, and ChatGPT-4 into the educational fabric of high-performance computing. This textbook revolutionizes learning by combining cutting-edge AI with traditional educational methodologies to offer a dynamic, interactive experience through Jupyter Books. It enables code execution directly from the web browser, enhancing the learning process with real-time feedback. ## Key Features @@ -60,7 +60,7 @@ The authors have made every effort to ensure that the information in this book i --- -**Book Version:** Interactive OpenMP Programming Book — Version 1.0 +**Book Version:** Interactive OpenMP Programming — Version 1.0 **Copyright:** © 2024 Xinyao Yi et al. All rights reserved. From 75e9ea3c2b6c6d133299e96fcfeb2eea873c8ad0 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 11 May 2025 16:02:11 -0400 Subject: [PATCH 87/91] Add the learning objectives for chapter 1 --- src/Openmp_C/0_Learning_Objectives.ipynb | 55 ++++++++++++++++++++++++ src/_toc.yml | 1 + 2 files changed, 56 insertions(+) create mode 100644 src/Openmp_C/0_Learning_Objectives.ipynb diff --git a/src/Openmp_C/0_Learning_Objectives.ipynb b/src/Openmp_C/0_Learning_Objectives.ipynb new file mode 100644 index 0000000..bd3b3ce --- /dev/null +++ b/src/Openmp_C/0_Learning_Objectives.ipynb @@ -0,0 +1,55 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "445ceffe-9df5-46c9-b717-8701c41854e7", + "metadata": {}, + "source": [ + "# Learning Objectives\n", + "\n", + "By the end of this chapter, students will be able to:\n", + "\n", + "1. **Understand the motivation for parallel computing** and explain the limitations of serial execution in the context of modern multi-core architectures.\n", + "\n", + "2. **Describe the shared memory programming model** and distinguish between shared and private variables in OpenMP.\n", + "\n", + "3. **Explain OpenMP’s fork-join execution model**, including the roles of the master thread and worker threads during parallel regions.\n", + "\n", + "4. **Identify the basic structure of an OpenMP program**, including how and where to insert OpenMP directives to parallelize code.\n", + "\n", + "5. **Use basic OpenMP runtime functions** to control and query the number of threads.\n", + "\n", + "6. **Recognize the advantages and limitations of OpenMP**, particularly in comparison to other parallel programming models such as MPI or Pthreads.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f3e2a00-9b76-45e1-88ed-c91da492e23b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/_toc.yml b/src/_toc.yml index e2a2c40..4e6fae3 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -10,6 +10,7 @@ parts: chapters: - file: Ch1_OpenmpIntro sections: + - file: Openmp_C/0_Learning_Objectives.ipynb - file: Openmp_C/1_IntroductionOfOpenMP.ipynb - file: Openmp_C/2_Syntax.ipynb - file: Openmp_C/3_Performance.ipynb From ec94c4c466b63df6aaf0793e4d8ddfc159df0ace Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 11 May 2025 16:26:37 -0400 Subject: [PATCH 88/91] Add the learning objectives for Chapter2, Chapter 3 and Chapter 4 --- .../0_Learning_Objectives.ipynb | 81 +++++++++++++++++++ .../0_Learning_Objectives.ipynb | 77 ++++++++++++++++++ src/Openmp_C/0_Learning_Objectives.ipynb | 33 ++++++-- .../0_Learning_Objectives.ipynb | 78 ++++++++++++++++++ src/_toc.yml | 3 + 5 files changed, 265 insertions(+), 7 deletions(-) create mode 100644 src/GPUAccelerators/0_Learning_Objectives.ipynb create mode 100644 src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb create mode 100644 src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb diff --git a/src/GPUAccelerators/0_Learning_Objectives.ipynb b/src/GPUAccelerators/0_Learning_Objectives.ipynb new file mode 100644 index 0000000..67ba275 --- /dev/null +++ b/src/GPUAccelerators/0_Learning_Objectives.ipynb @@ -0,0 +1,81 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d85282e4-00fa-4786-9237-bfba6e9a3f09", + "metadata": {}, + "source": [ + "\n", + "# Learning Objectives\n", + "\n", + "This chapter introduces students to GPU offloading with OpenMP, focusing on device constructs, memory management, parallel execution, and performance optimization. By the end of this chapter, students will be able to:\n", + "\n", + "---\n", + "\n", + "## 1. Remember & Understand\n", + "- Describe the role and architectural characteristics of GPU accelerators in modern parallel computing.\n", + "- Explain OpenMP’s device constructs (`target`, `teams`, `distribute`, etc.) and their purpose in offloading computation to GPUs.\n", + "- Understand the concepts of data mapping and the use of `map` clauses for host-device memory transfer.\n", + "- Recognize how OpenMP supports asynchronous execution and explicit memory management on devices.\n", + "\n", + "---\n", + "\n", + "## 2. Apply\n", + "- Write OpenMP code using `target`, `teams`, and `distribute` to implement GPU offloading for compute-intensive kernels.\n", + "- Use `map`, `target data`, and `target update` clauses to control data movement between host and device memory.\n", + "- Implement asynchronous execution using the `nowait` clause and task dependencies to overlap computation and communication.\n", + "- Allocate and deallocate GPU memory using OpenMP runtime functions.\n", + "- Apply best practices for parallel execution and synchronization on GPU devices.\n", + "\n", + "---\n", + "\n", + "## 3. Analyze\n", + "- Analyze the impact of different memory mapping strategies on data locality and device performance.\n", + "- Compare different parallel constructs (`teams`, `distribute`, `parallel for`) in terms of their execution behavior and applicability.\n", + "- Investigate the effects of loop scheduling and thread distribution on GPU workload balancing.\n", + "\n", + "---\n", + "\n", + "## 4. Evaluate\n", + "- Evaluate the performance benefits and trade-offs of GPU offloading for a given problem.\n", + "- Assess the correctness and efficiency of data transfers and asynchronous execution mechanisms.\n", + "- Critique the effectiveness of tuning strategies for memory usage, thread configuration, and offload scope.\n", + "\n", + "---\n", + "\n", + "## 5. Create\n", + "- Design and implement optimized GPU-offloaded applications using a combination of OpenMP directives and memory management techniques.\n", + "- Develop high-performance OpenMP programs that utilize advanced features such as dependency management, asynchronous execution, and architecture-specific tuning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc54282e-fa68-4e98-b260-6f95f6418bfd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb b/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb new file mode 100644 index 0000000..7b56984 --- /dev/null +++ b/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb @@ -0,0 +1,77 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d85282e4-00fa-4786-9237-bfba6e9a3f09", + "metadata": {}, + "source": [ + "\n", + "# Learning Objectives\n", + "\n", + "This chapter enables students to progressively develop their understanding and skills in OpenMP programming. By the end of this chapter, students will be able to:\n", + "\n", + "---\n", + "\n", + "## 1. Remember & Understand\n", + "- Describe the structure and principles of MIMD architecture and its relevance to shared-memory parallel computing.\n", + "- Explain the execution model of OpenMP, including the role of threads, teams, and synchronization points.\n", + "\n", + "---\n", + "\n", + "## 2. Apply\n", + "- Implement parallel regions in OpenMP using the `parallel` and `teams` directives to create SPMD-style programs.\n", + "- Use `barrier`, `ordered`, and other synchronization constructs to coordinate thread execution safely and correctly.\n", + "- Apply OpenMP task constructs to express asynchronous and irregular parallelism in C/C++ programs.\n", + "- Distribute workloads explicitly across threads using OpenMP directives like `single`, `sections`, `for`, and `distribute`.\n", + "\n", + "---\n", + "\n", + "## 3. Analyze\n", + "- Differentiate between the use cases and performance implications of `parallel`, `teams`, and `task` constructs.\n", + "- Analyze synchronization needs in a parallel program and determine appropriate mechanisms to avoid race conditions.\n", + "- Inspect the impact of various work-sharing strategies on performance and load balance.\n", + "\n", + "---\n", + "\n", + "## 4. Evaluate\n", + "- Evaluate the scalability and correctness of OpenMP programs under different architectural assumptions (e.g., multicore vs. multi-CPU).\n", + "- Critique the suitability of selected OpenMP directives for specific parallel patterns or problem domains.\n", + "\n", + "---\n", + "\n", + "## 5. Create\n", + "- Design parallel solutions for real-world problems by combining OpenMP directives effectively and modularly.\n", + "- Develop optimized OpenMP programs that demonstrate good parallel design, proper synchronization, and balanced workload distribution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc54282e-fa68-4e98-b260-6f95f6418bfd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Openmp_C/0_Learning_Objectives.ipynb b/src/Openmp_C/0_Learning_Objectives.ipynb index bd3b3ce..6bed95c 100644 --- a/src/Openmp_C/0_Learning_Objectives.ipynb +++ b/src/Openmp_C/0_Learning_Objectives.ipynb @@ -7,19 +7,38 @@ "source": [ "# Learning Objectives\n", "\n", - "By the end of this chapter, students will be able to:\n", + "This chapter introduces the foundational concepts of OpenMP and shared-memory parallelism. By the end of this chapter, students will be able to:\n", "\n", - "1. **Understand the motivation for parallel computing** and explain the limitations of serial execution in the context of modern multi-core architectures.\n", + "---\n", "\n", - "2. **Describe the shared memory programming model** and distinguish between shared and private variables in OpenMP.\n", + "## 1. Remember & Understand\n", + "- Understand the motivation for parallel computing and explain the limitations of serial execution in modern computing environments.\n", + "- Describe the shared memory programming model and distinguish between shared and private variables.\n", + "- Explain OpenMP’s fork-join execution model, including the roles of the master thread and worker threads during parallel regions.\n", "\n", - "3. **Explain OpenMP’s fork-join execution model**, including the roles of the master thread and worker threads during parallel regions.\n", + "---\n", "\n", - "4. **Identify the basic structure of an OpenMP program**, including how and where to insert OpenMP directives to parallelize code.\n", + "## 2. Apply\n", + "- Identify the basic structure of an OpenMP program and correctly insert directives to create parallel regions.\n", + "- Use OpenMP runtime functions and environment variables (e.g., `omp_set_num_threads`, `OMP_NUM_THREADS`) to control and query thread behavior.\n", "\n", - "5. **Use basic OpenMP runtime functions** to control and query the number of threads.\n", + "---\n", "\n", - "6. **Recognize the advantages and limitations of OpenMP**, particularly in comparison to other parallel programming models such as MPI or Pthreads.\n" + "## 3. Analyze\n", + "- Analyze simple OpenMP programs to detect data sharing issues such as race conditions.\n", + "- Differentiate between OpenMP and other parallel programming models such as MPI and Pthreads in terms of use cases and memory models.\n", + "\n", + "---\n", + "\n", + "## 4. Evaluate\n", + "- Assess the suitability of OpenMP for various computational tasks, based on program structure and target architecture.\n", + "- Evaluate the readability, portability, and efficiency of OpenMP programs.\n", + "\n", + "---\n", + "\n", + "## 5. Create\n", + "- Construct simple OpenMP programs using the parallel directive to demonstrate shared-memory parallelism.\n", + "- Modify existing serial code to introduce parallelism while preserving correctness." ] }, { diff --git a/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb new file mode 100644 index 0000000..f1c8200 --- /dev/null +++ b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb @@ -0,0 +1,78 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d85282e4-00fa-4786-9237-bfba6e9a3f09", + "metadata": {}, + "source": [ + "\n", + "# Learning Objectives\n", + "\n", + "This chapter enables students to effectively utilize SIMD constructs in OpenMP to exploit data-level parallelism and optimize program performance. By the end of this chapter, students will be able to:\n", + "\n", + "---\n", + "\n", + "## 1. Remember & Understand\n", + "- Describe the principles of SIMD and how it enables data-level parallelism on modern processors.\n", + "- Understand the use of OpenMP SIMD constructs (`simd`, `declare simd`, etc.) and related clauses (`aligned`, `linear`, etc.).\n", + "- Explain the benefits and challenges of vectorization in high-performance computing.\n", + "\n", + "---\n", + "\n", + "## 2. Apply\n", + "- Use `#pragma omp simd` to vectorize loops and improve data throughput.\n", + "- Apply `declare simd` for vectorizing user-defined functions in C/C++.\n", + "- Use `aligned`, `linear`, and `private` clauses to control data access and memory alignment in SIMD loops.\n", + "- Implement SIMD reductions and scan operations using OpenMP constructs.\n", + "\n", + "---\n", + "\n", + "## 3. Analyze\n", + "- Analyze the performance impact of SIMD vectorization on different types of loops.\n", + "- Investigate memory alignment and its effect on SIMD performance.\n", + "- Differentiate between scalar and vectorized versions of loops to identify optimization opportunities.\n", + "\n", + "---\n", + "\n", + "## 4. Evaluate\n", + "- Evaluate the effectiveness of SIMD vectorization strategies on performance-critical code.\n", + "- Critically assess the suitability of specific OpenMP SIMD constructs for various data-parallel computation patterns.\n", + "\n", + "---\n", + "\n", + "## 5. Create\n", + "- Design vectorized algorithms using OpenMP SIMD directives that demonstrate high efficiency and correctness.\n", + "- Develop applications that integrate function vectorization, memory alignment, and reductions for maximum SIMD utilization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc54282e-fa68-4e98-b260-6f95f6418bfd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/_toc.yml b/src/_toc.yml index 4e6fae3..d2a66bf 100644 --- a/src/_toc.yml +++ b/src/_toc.yml @@ -16,6 +16,7 @@ parts: - file: Openmp_C/3_Performance.ipynb - file: Ch2_MulticoreMultiCPU sections: + - file: MultiCoreMultiCPU/0_Learning_Objectives.ipynb - file: MultiCoreMultiCPU/1_MIMDArchitecture.ipynb - file: MultiCoreMultiCPU/2_UsingOpenMP_parallel.ipynb - file: MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -26,6 +27,7 @@ parts: - file: MultiCoreMultiCPU/6_ExplicitDistribution.ipynb - file: Ch3_SIMDVector sections: + - file: SIMDandVectorArchitecture/0_Learning_Objectives.ipynb - file: SIMDandVectorArchitecture/1_IntroductionToSIMDAndVectorization.ipynb - file: SIMDandVectorArchitecture/2_OpenMPSIMDConstructsAndClauses.ipynb - file: SIMDandVectorArchitecture/3_UtilizingSIMDDirectivesForLoopVectorization.ipynb @@ -36,6 +38,7 @@ parts: - file: SIMDandVectorArchitecture/8_RealWorldExamplesAndCaseStudies.ipynb - file: Ch4_GPUAccel sections: + - file: GPUAccelerators/0_Learning_Objectives.ipynb - file: GPUAccelerators/1_Introduction.ipynb - file: GPUAccelerators/2_OpenMPDeviceConstructs.ipynb - file: GPUAccelerators/3_MappingDataToGPUDevices.ipynb From 4e97d99ae3c2c357b82e188760f625499f3c9818 Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 11 May 2025 16:31:00 -0400 Subject: [PATCH 89/91] Fixed the labels in the subtitles --- src/GPUAccelerators/0_Learning_Objectives.ipynb | 10 +++++----- src/Openmp_C/0_Learning_Objectives.ipynb | 10 +++++----- .../0_Learning_Objectives.ipynb | 10 +++++----- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/GPUAccelerators/0_Learning_Objectives.ipynb b/src/GPUAccelerators/0_Learning_Objectives.ipynb index 67ba275..c3784fe 100644 --- a/src/GPUAccelerators/0_Learning_Objectives.ipynb +++ b/src/GPUAccelerators/0_Learning_Objectives.ipynb @@ -12,7 +12,7 @@ "\n", "---\n", "\n", - "## 1. Remember & Understand\n", + "## Remember & Understand\n", "- Describe the role and architectural characteristics of GPU accelerators in modern parallel computing.\n", "- Explain OpenMP’s device constructs (`target`, `teams`, `distribute`, etc.) and their purpose in offloading computation to GPUs.\n", "- Understand the concepts of data mapping and the use of `map` clauses for host-device memory transfer.\n", @@ -20,7 +20,7 @@ "\n", "---\n", "\n", - "## 2. Apply\n", + "## Apply\n", "- Write OpenMP code using `target`, `teams`, and `distribute` to implement GPU offloading for compute-intensive kernels.\n", "- Use `map`, `target data`, and `target update` clauses to control data movement between host and device memory.\n", "- Implement asynchronous execution using the `nowait` clause and task dependencies to overlap computation and communication.\n", @@ -29,21 +29,21 @@ "\n", "---\n", "\n", - "## 3. Analyze\n", + "## Analyze\n", "- Analyze the impact of different memory mapping strategies on data locality and device performance.\n", "- Compare different parallel constructs (`teams`, `distribute`, `parallel for`) in terms of their execution behavior and applicability.\n", "- Investigate the effects of loop scheduling and thread distribution on GPU workload balancing.\n", "\n", "---\n", "\n", - "## 4. Evaluate\n", + "## Evaluate\n", "- Evaluate the performance benefits and trade-offs of GPU offloading for a given problem.\n", "- Assess the correctness and efficiency of data transfers and asynchronous execution mechanisms.\n", "- Critique the effectiveness of tuning strategies for memory usage, thread configuration, and offload scope.\n", "\n", "---\n", "\n", - "## 5. Create\n", + "## Create\n", "- Design and implement optimized GPU-offloaded applications using a combination of OpenMP directives and memory management techniques.\n", "- Develop high-performance OpenMP programs that utilize advanced features such as dependency management, asynchronous execution, and architecture-specific tuning." ] diff --git a/src/Openmp_C/0_Learning_Objectives.ipynb b/src/Openmp_C/0_Learning_Objectives.ipynb index 6bed95c..d79fb06 100644 --- a/src/Openmp_C/0_Learning_Objectives.ipynb +++ b/src/Openmp_C/0_Learning_Objectives.ipynb @@ -11,32 +11,32 @@ "\n", "---\n", "\n", - "## 1. Remember & Understand\n", + "## Remember & Understand\n", "- Understand the motivation for parallel computing and explain the limitations of serial execution in modern computing environments.\n", "- Describe the shared memory programming model and distinguish between shared and private variables.\n", "- Explain OpenMP’s fork-join execution model, including the roles of the master thread and worker threads during parallel regions.\n", "\n", "---\n", "\n", - "## 2. Apply\n", + "## Apply\n", "- Identify the basic structure of an OpenMP program and correctly insert directives to create parallel regions.\n", "- Use OpenMP runtime functions and environment variables (e.g., `omp_set_num_threads`, `OMP_NUM_THREADS`) to control and query thread behavior.\n", "\n", "---\n", "\n", - "## 3. Analyze\n", + "## Analyze\n", "- Analyze simple OpenMP programs to detect data sharing issues such as race conditions.\n", "- Differentiate between OpenMP and other parallel programming models such as MPI and Pthreads in terms of use cases and memory models.\n", "\n", "---\n", "\n", - "## 4. Evaluate\n", + "## Evaluate\n", "- Assess the suitability of OpenMP for various computational tasks, based on program structure and target architecture.\n", "- Evaluate the readability, portability, and efficiency of OpenMP programs.\n", "\n", "---\n", "\n", - "## 5. Create\n", + "## Create\n", "- Construct simple OpenMP programs using the parallel directive to demonstrate shared-memory parallelism.\n", "- Modify existing serial code to introduce parallelism while preserving correctness." ] diff --git a/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb index f1c8200..b07c048 100644 --- a/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb +++ b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb @@ -12,14 +12,14 @@ "\n", "---\n", "\n", - "## 1. Remember & Understand\n", + "## Remember & Understand\n", "- Describe the principles of SIMD and how it enables data-level parallelism on modern processors.\n", "- Understand the use of OpenMP SIMD constructs (`simd`, `declare simd`, etc.) and related clauses (`aligned`, `linear`, etc.).\n", "- Explain the benefits and challenges of vectorization in high-performance computing.\n", "\n", "---\n", "\n", - "## 2. Apply\n", + "## Apply\n", "- Use `#pragma omp simd` to vectorize loops and improve data throughput.\n", "- Apply `declare simd` for vectorizing user-defined functions in C/C++.\n", "- Use `aligned`, `linear`, and `private` clauses to control data access and memory alignment in SIMD loops.\n", @@ -27,20 +27,20 @@ "\n", "---\n", "\n", - "## 3. Analyze\n", + "## Analyze\n", "- Analyze the performance impact of SIMD vectorization on different types of loops.\n", "- Investigate memory alignment and its effect on SIMD performance.\n", "- Differentiate between scalar and vectorized versions of loops to identify optimization opportunities.\n", "\n", "---\n", "\n", - "## 4. Evaluate\n", + "## Evaluate\n", "- Evaluate the effectiveness of SIMD vectorization strategies on performance-critical code.\n", "- Critically assess the suitability of specific OpenMP SIMD constructs for various data-parallel computation patterns.\n", "\n", "---\n", "\n", - "## 5. Create\n", + "## Create\n", "- Design vectorized algorithms using OpenMP SIMD directives that demonstrate high efficiency and correctness.\n", "- Develop applications that integrate function vectorization, memory alignment, and reductions for maximum SIMD utilization." ] From 3f4fb99d06b9b7ff9c9952bb68f5bbdbb777cc6f Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 11 May 2025 16:37:14 -0400 Subject: [PATCH 90/91] Change the format of the learning objectives --- src/GPUAccelerators/0_Learning_Objectives.ipynb | 10 +++++----- src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb | 10 +++++----- src/Openmp_C/0_Learning_Objectives.ipynb | 10 +++++----- .../0_Learning_Objectives.ipynb | 10 +++++----- 4 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/GPUAccelerators/0_Learning_Objectives.ipynb b/src/GPUAccelerators/0_Learning_Objectives.ipynb index c3784fe..a693f92 100644 --- a/src/GPUAccelerators/0_Learning_Objectives.ipynb +++ b/src/GPUAccelerators/0_Learning_Objectives.ipynb @@ -12,7 +12,7 @@ "\n", "---\n", "\n", - "## Remember & Understand\n", + "**Remember & Understand**\n", "- Describe the role and architectural characteristics of GPU accelerators in modern parallel computing.\n", "- Explain OpenMP’s device constructs (`target`, `teams`, `distribute`, etc.) and their purpose in offloading computation to GPUs.\n", "- Understand the concepts of data mapping and the use of `map` clauses for host-device memory transfer.\n", @@ -20,7 +20,7 @@ "\n", "---\n", "\n", - "## Apply\n", + "**Apply**\n", "- Write OpenMP code using `target`, `teams`, and `distribute` to implement GPU offloading for compute-intensive kernels.\n", "- Use `map`, `target data`, and `target update` clauses to control data movement between host and device memory.\n", "- Implement asynchronous execution using the `nowait` clause and task dependencies to overlap computation and communication.\n", @@ -29,21 +29,21 @@ "\n", "---\n", "\n", - "## Analyze\n", + "**Analyze**\n", "- Analyze the impact of different memory mapping strategies on data locality and device performance.\n", "- Compare different parallel constructs (`teams`, `distribute`, `parallel for`) in terms of their execution behavior and applicability.\n", "- Investigate the effects of loop scheduling and thread distribution on GPU workload balancing.\n", "\n", "---\n", "\n", - "## Evaluate\n", + "**Evaluate**\n", "- Evaluate the performance benefits and trade-offs of GPU offloading for a given problem.\n", "- Assess the correctness and efficiency of data transfers and asynchronous execution mechanisms.\n", "- Critique the effectiveness of tuning strategies for memory usage, thread configuration, and offload scope.\n", "\n", "---\n", "\n", - "## Create\n", + "**Create**\n", "- Design and implement optimized GPU-offloaded applications using a combination of OpenMP directives and memory management techniques.\n", "- Develop high-performance OpenMP programs that utilize advanced features such as dependency management, asynchronous execution, and architecture-specific tuning." ] diff --git a/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb b/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb index 7b56984..e153ed0 100644 --- a/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb +++ b/src/MultiCoreMultiCPU/0_Learning_Objectives.ipynb @@ -12,13 +12,13 @@ "\n", "---\n", "\n", - "## 1. Remember & Understand\n", + "**Remember & Understand**\n", "- Describe the structure and principles of MIMD architecture and its relevance to shared-memory parallel computing.\n", "- Explain the execution model of OpenMP, including the role of threads, teams, and synchronization points.\n", "\n", "---\n", "\n", - "## 2. Apply\n", + "**Apply**\n", "- Implement parallel regions in OpenMP using the `parallel` and `teams` directives to create SPMD-style programs.\n", "- Use `barrier`, `ordered`, and other synchronization constructs to coordinate thread execution safely and correctly.\n", "- Apply OpenMP task constructs to express asynchronous and irregular parallelism in C/C++ programs.\n", @@ -26,20 +26,20 @@ "\n", "---\n", "\n", - "## 3. Analyze\n", + "**Analyze**\n", "- Differentiate between the use cases and performance implications of `parallel`, `teams`, and `task` constructs.\n", "- Analyze synchronization needs in a parallel program and determine appropriate mechanisms to avoid race conditions.\n", "- Inspect the impact of various work-sharing strategies on performance and load balance.\n", "\n", "---\n", "\n", - "## 4. Evaluate\n", + "**Evaluate**\n", "- Evaluate the scalability and correctness of OpenMP programs under different architectural assumptions (e.g., multicore vs. multi-CPU).\n", "- Critique the suitability of selected OpenMP directives for specific parallel patterns or problem domains.\n", "\n", "---\n", "\n", - "## 5. Create\n", + "**Create**\n", "- Design parallel solutions for real-world problems by combining OpenMP directives effectively and modularly.\n", "- Develop optimized OpenMP programs that demonstrate good parallel design, proper synchronization, and balanced workload distribution." ] diff --git a/src/Openmp_C/0_Learning_Objectives.ipynb b/src/Openmp_C/0_Learning_Objectives.ipynb index d79fb06..9c056b8 100644 --- a/src/Openmp_C/0_Learning_Objectives.ipynb +++ b/src/Openmp_C/0_Learning_Objectives.ipynb @@ -11,32 +11,32 @@ "\n", "---\n", "\n", - "## Remember & Understand\n", + "**Remember & Understand**\n", "- Understand the motivation for parallel computing and explain the limitations of serial execution in modern computing environments.\n", "- Describe the shared memory programming model and distinguish between shared and private variables.\n", "- Explain OpenMP’s fork-join execution model, including the roles of the master thread and worker threads during parallel regions.\n", "\n", "---\n", "\n", - "## Apply\n", + "**Apply**\n", "- Identify the basic structure of an OpenMP program and correctly insert directives to create parallel regions.\n", "- Use OpenMP runtime functions and environment variables (e.g., `omp_set_num_threads`, `OMP_NUM_THREADS`) to control and query thread behavior.\n", "\n", "---\n", "\n", - "## Analyze\n", + "**Analyze**\n", "- Analyze simple OpenMP programs to detect data sharing issues such as race conditions.\n", "- Differentiate between OpenMP and other parallel programming models such as MPI and Pthreads in terms of use cases and memory models.\n", "\n", "---\n", "\n", - "## Evaluate\n", + "**Evaluate**\n", "- Assess the suitability of OpenMP for various computational tasks, based on program structure and target architecture.\n", "- Evaluate the readability, portability, and efficiency of OpenMP programs.\n", "\n", "---\n", "\n", - "## Create\n", + "**Create**\n", "- Construct simple OpenMP programs using the parallel directive to demonstrate shared-memory parallelism.\n", "- Modify existing serial code to introduce parallelism while preserving correctness." ] diff --git a/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb index b07c048..c8ece29 100644 --- a/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb +++ b/src/SIMDandVectorArchitecture/0_Learning_Objectives.ipynb @@ -12,14 +12,14 @@ "\n", "---\n", "\n", - "## Remember & Understand\n", + "**Remember & Understand**\n", "- Describe the principles of SIMD and how it enables data-level parallelism on modern processors.\n", "- Understand the use of OpenMP SIMD constructs (`simd`, `declare simd`, etc.) and related clauses (`aligned`, `linear`, etc.).\n", "- Explain the benefits and challenges of vectorization in high-performance computing.\n", "\n", "---\n", "\n", - "## Apply\n", + "**Apply**\n", "- Use `#pragma omp simd` to vectorize loops and improve data throughput.\n", "- Apply `declare simd` for vectorizing user-defined functions in C/C++.\n", "- Use `aligned`, `linear`, and `private` clauses to control data access and memory alignment in SIMD loops.\n", @@ -27,20 +27,20 @@ "\n", "---\n", "\n", - "## Analyze\n", + "**Analyze**\n", "- Analyze the performance impact of SIMD vectorization on different types of loops.\n", "- Investigate memory alignment and its effect on SIMD performance.\n", "- Differentiate between scalar and vectorized versions of loops to identify optimization opportunities.\n", "\n", "---\n", "\n", - "## Evaluate\n", + "**Evaluate**\n", "- Evaluate the effectiveness of SIMD vectorization strategies on performance-critical code.\n", "- Critically assess the suitability of specific OpenMP SIMD constructs for various data-parallel computation patterns.\n", "\n", "---\n", "\n", - "## Create\n", + "**Create**\n", "- Design vectorized algorithms using OpenMP SIMD directives that demonstrate high efficiency and correctness.\n", "- Develop applications that integrate function vectorization, memory alignment, and reductions for maximum SIMD utilization." ] From 78686c5fc0b4845edec558ee339bec83b48c5b8d Mon Sep 17 00:00:00 2001 From: Xinyao Yi Date: Sun, 11 May 2025 16:59:43 -0400 Subject: [PATCH 91/91] Fixed the cell type in chapter 2 3_UsingOpenMP_teams --- .../3_UsingOpenMP_teams.ipynb | 487 ++++++++++++++---- 1 file changed, 386 insertions(+), 101 deletions(-) diff --git a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb index cddfb88..532d271 100644 --- a/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb +++ b/src/MultiCoreMultiCPU/3_UsingOpenMP_teams.ipynb @@ -108,7 +108,7 @@ }, { "cell_type": "markdown", - "id": "463500c6-2694-4874-af2f-70fcc0ac9987", + "id": "7f58a510-319e-4321-b57e-fb231d8bd0cb", "metadata": {}, "source": [ "## Interaction with Other Directives\n", @@ -119,9 +119,19 @@ "\n", "The `distribute` directive is used to distribute the iterations of a loop across the teams created by the `teams` directive. This combination is particularly useful for data parallelism where each team works on a different portion of the data.\n", "\n", - "**Example:** Distributing loop iterations across teams to perform a parallel reduction.\n", + "**Example:** Distributing loop iterations across teams to perform a parallel reduction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ddd3a9d1-ace3-4800-a246-16caaf9ac350", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -143,18 +153,33 @@ " printf(\"Sum: %d\\n\", sum);\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "9cb12acb-252f-4a21-9921-0670425415a2", + "metadata": {}, + "source": [ "In this example, the loop iterations are distributed across teams, and each team contributes to the reduction operation to calculate the sum of the array elements.\n", "\n", "### Teams and Parallel Directives\n", "\n", "The `teams` directive can also be combined with the `parallel` directive to create nested parallelism. Within each team, the `parallel` directive creates a parallel region where multiple threads can work concurrently.\n", "\n", - "**Example:** Using nested parallelism with the `teams` and `parallel` directives to perform matrix multiplication.\n", + "**Example:** Using nested parallelism with the `teams` and `parallel` directives to perform matrix multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cae702db-110d-46e9-8349-2ce200433c18", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -186,18 +211,33 @@ " // ...\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "036fd098-6521-4918-9b2a-a25c4df7296f", + "metadata": {}, + "source": [ "In this example, the outer loop iterations (over `i` and `j`) are distributed across teams, and within each team, the loop iterations are executed in parallel by the team's threads.\n", "\n", "### Teams and Target Directives\n", "\n", "The `teams` directive is commonly used with the `target` directive for offloading computations to a device, such as a GPU. The `target` directive specifies that the code block should be executed on the device, and the `teams` directive creates teams of threads on the device to execute the code.\n", "\n", - "**Example:** Offloading a computation to a device and using teams to perform the computation in parallel.\n", + "**Example:** Offloading a computation to a device and using teams to perform the computation in parallel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c32c960-22a4-424b-8f9b-cf688d0c83a8", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -221,9 +261,14 @@ " // ...\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "463500c6-2694-4874-af2f-70fcc0ac9987", + "metadata": {}, + "source": [ "In this example, the computation of the element-wise sum of two arrays is offloaded to a device. The `teams` directive is used to create teams of threads on the device, and the `distribute parallel for` construct is used to distribute the loop iterations across the teams and execute them in parallel.\n", "\n", "### Summary\n", @@ -233,7 +278,7 @@ }, { "cell_type": "markdown", - "id": "ee8d1f71-032d-484f-a98c-b9fc8745b98a", + "id": "7b48b5e3-935b-4aae-a27e-2385bad1afeb", "metadata": {}, "source": [ "## Data Environment\n", @@ -249,9 +294,19 @@ "- **Firstprivate:** Similar to private, but each thread's copy is initialized with the value of the variable before entering the `teams` region.\n", "- **Reduction:** Variables with the reduction attribute are subject to a reduction operation at the end of the `teams` region.\n", "\n", - "### Example: Data-Sharing Attributes in Teams Region\n", + "### Example: Data-Sharing Attributes in Teams Region" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a8318d9-18ae-4a44-81b7-41597069faeb", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -272,9 +327,14 @@ " printf(\"Shared variable: %d\\n\", shared_var);\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "ee8d1f71-032d-484f-a98c-b9fc8745b98a", + "metadata": {}, + "source": [ "In this example, `shared_var` is shared among all teams and threads, while `private_var` is private to each thread. The value of `shared_var` is modified through a reduction operation within the parallel region inside the teams region.\n", "\n", "### Summary\n", @@ -284,7 +344,7 @@ }, { "cell_type": "markdown", - "id": "1f51b6ff-cb99-4636-bbc9-e47852385675", + "id": "127dd808-a615-4bcd-a45c-0f270ab034ac", "metadata": {}, "source": [ "## Clauses\n", @@ -297,9 +357,19 @@ "\n", "The `num_teams` clause specifies the number of teams to be created in the teams region.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65f7f95d-65cd-42ba-89bf-974b77381f09", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -309,18 +379,33 @@ " printf(\"Team %d out of %d teams\\n\", omp_get_team_num(), omp_get_num_teams());\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "ae91fb19-8179-4a27-9e60-cbb36e3b3eac", + "metadata": {}, + "source": [ "### thread_limit Clause\n", "\n", "**Syntax:** `thread_limit(integer-expression)`\n", "\n", "The `thread_limit` clause specifies the maximum number of threads that can be part of each team.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1afcb7c-2d83-44cd-b654-2a8c8aca5674", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -333,18 +418,33 @@ " }\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "016c2c12-33c1-4e56-bb99-78b55d9ac582", + "metadata": {}, + "source": [ "### reduction Clause\n", "\n", "**Syntax:** `reduction(operator: list)`\n", "\n", "The `reduction` clause is used to perform a reduction operation on variables that are private to each thread but shared across the teams.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baf8084d-a098-458b-b23e-267b71697126", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -362,18 +462,33 @@ " printf(\"Sum: %d\\n\", sum);\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "ec366aba-7216-4eed-8af0-3099adb4cb88", + "metadata": {}, + "source": [ "### default Clause\n", "\n", "**Syntax:** `default(shared | none)`\n", "\n", "The `default` clause sets the default data-sharing attribute for variables in the teams region.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e9bbbdc-a1b6-4049-97ea-19cdc5351767", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -384,18 +499,33 @@ " // Code that uses the variable x\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "2ede52b3-686e-4cfd-b86a-f9748d7da072", + "metadata": {}, + "source": [ "### allocate Clause\n", "\n", "**Syntax:** `allocate([allocator:] list)`\n", "\n", "The `allocate` clause specifies the allocator to be used for the variables in the list.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3571f0e-362d-4175-89d9-6245fce11dee", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -405,18 +535,33 @@ " // Code that uses the variable x\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "6ee7a9a4-0398-4b57-b79f-42d28a4ffb65", + "metadata": {}, + "source": [ "### shared Clause\n", "\n", "**Syntax:** `shared(list)`\n", "\n", "The `shared` clause specifies that the data within a parallel region is shared among all threads.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1292a480-0e81-4660-8fc5-ba434ec11061", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -426,18 +571,33 @@ " // All threads in the team share the variable x\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "c0e56278-dc36-4c37-92b2-9cb2f990c138", + "metadata": {}, + "source": [ "### private Clause\n", "\n", "**Syntax:** `private(list)`\n", "\n", "The `private` clause specifies that each thread should have its own instance of a variable.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95d2147f-3da4-4f84-acf9-5df4a6cd2fa2", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -447,18 +607,33 @@ " // Each thread has its own private copy of x\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "0f467cd5-93dc-4581-8ed7-7178ed278206", + "metadata": {}, + "source": [ "### firstprivate Clause\n", "\n", "**Syntax:** `firstprivate(list)`\n", "\n", "The `firstprivate` clause provides each thread with its own copy of a variable and initializes each copy with the value of the variable at the time the parallel region is entered.\n", "\n", - "**Example:**\n", + "**Example:**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f70cd725-6de0-4f98-8ca5-a408ac35491e", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -468,9 +643,14 @@ " // Each thread has its own copy of x, initialized with the value of x\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "1f51b6ff-cb99-4636-bbc9-e47852385675", + "metadata": {}, + "source": [ "### Summary\n", "\n", "Clauses provide a powerful way to customize the behavior of the `teams` directive in OpenMP. By using clauses like `num_teams`, `thread_limit`, `reduction`, `default`, `allocate`, `shared`, `private`, and `firstprivate`, programmers can control various aspects of the teams' behavior and the data environment." @@ -478,7 +658,7 @@ }, { "cell_type": "markdown", - "id": "1d39d0c9-4948-4868-87a0-f94bd39138a9", + "id": "b82e1917-d905-46b5-89fd-f20bdf7c22d8", "metadata": {}, "source": [ "## Targeting Devices\n", @@ -491,9 +671,19 @@ "\n", "**Example: Vector Addition on a GPU**\n", "\n", - "Consider the following example where two arrays are added element-wise and the result is stored in a third array:\n", + "Consider the following example where two arrays are added element-wise and the result is stored in a third array:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43762dad-f946-44bb-908c-51c46a9969df", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -522,9 +712,14 @@ " }\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "1ddfd089-1afe-4be0-b2c2-50fa6a1c8203", + "metadata": {}, + "source": [ "In this example, the `target teams` directive offloads the addition of arrays `a` and `b` to a GPU. The `map` clauses specify how data is transferred between the host and the device. The `distribute parallel for` directive ensures that the computation is performed in parallel by the teams of threads on the device.\n", "\n", "### Leveraging Device Parallelism\n", @@ -538,7 +733,7 @@ }, { "cell_type": "markdown", - "id": "16395d7a-5314-4c55-9c6d-0405abf0c703", + "id": "fdd422fd-c188-41e4-a7db-dde3ea5d89df", "metadata": {}, "source": [ "## Best Practices for Effective Use of Teams Directive\n", @@ -553,9 +748,19 @@ "\n", "Achieving a balanced distribution of work among teams is key to avoiding performance bottlenecks. Utilize the `distribute` directive in tandem with `teams` to ensure an equitable assignment of loop iterations or other computational tasks across the teams.\n", "\n", - "**Example: Workload Distribution**\n", + "**Example: Workload Distribution**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6d905c1-d945-4f74-b8b4-d6547e964e04", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -577,16 +782,31 @@ " }\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "360fd88f-b12c-4e76-bf4c-573f8db5321c", + "metadata": {}, + "source": [ "### Minimizing Data Movement\n", "\n", "Data transfer between the host and the device can significantly impact performance. Employ the `map` clause with precision to reduce unnecessary data movement. Additionally, explore techniques like data prefetching and overlapping data transfers with computation to enhance data locality.\n", "\n", - "**Example: Efficient Data Movement**\n", + "**Example: Efficient Data Movement**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87a1a773-4512-43a2-a704-64c31f84f7c2", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -610,16 +830,31 @@ " }\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "07ece1f6-a5af-4470-9295-1b30b96066e2", + "metadata": {}, + "source": [ "### Efficient Reductions\n", "\n", "Ensure that reductions are performed efficiently, especially when using the `reduction` clause with the `teams` directive. Implement parallel reduction algorithms that leverage the device's parallel processing capabilities to avoid bottlenecks.\n", "\n", - "**Example: Parallel Reduction**\n", + "**Example: Parallel Reduction**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94fd821b-3141-4641-82d0-8c549be75c4c", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -646,9 +881,14 @@ " printf(\"Sum: %f\\n\", sum);\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "16395d7a-5314-4c55-9c6d-0405abf0c703", + "metadata": {}, + "source": [ "### Debugging and Profiling\n", "\n", "Leverage OpenMP-aware debugging and profiling tools to identify and address performance bottlenecks. Regularly verify the correctness of parallel execution to ensure the expected behavior of your application.\n", @@ -660,7 +900,7 @@ }, { "cell_type": "markdown", - "id": "9fb90664-069e-4702-b56a-fdf287072021", + "id": "ebd05eb0-8078-4953-b82f-1b21daba4b51", "metadata": {}, "source": [ "## Advanced Topics\n", @@ -671,9 +911,19 @@ "\n", "OpenMP supports nested parallelism, where a parallel region can be defined inside another parallel region. This can be particularly useful when using the `teams` directive to create a hierarchical parallelism model.\n", "\n", - "**Example: Nested Parallelism**\n", + "**Example: Nested Parallelism**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06990fd6-955b-41dd-aeff-777355183815", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -688,18 +938,33 @@ " }\n", " }\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "7eb562b4-44ee-4348-86b2-0a375278e79a", + "metadata": {}, + "source": [ "In this example, an outer parallel region is created by the `teams` directive, and an inner parallel region is created by the `parallel` directive. Each team of threads executes the inner parallel region independently.\n", "\n", "### SIMD Parallelism\n", "\n", "The `teams` directive can be combined with SIMD (Single Instruction, Multiple Data) constructs to exploit vector parallelism on devices that support SIMD instructions.\n", "\n", - "**Example: SIMD Parallelism**\n", + "**Example: SIMD Parallelism**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de740b6b-01a8-475c-a4be-3d25e90d39dc", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "\n", @@ -724,18 +989,33 @@ " }\n", "\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "908331fc-b84e-44ff-b4d1-4f11e7e8cb02", + "metadata": {}, + "source": [ "In this example, the `simd` directive is used within the loop to enable SIMD parallelism, allowing multiple elements of the array to be processed simultaneously by SIMD instructions.\n", "\n", "### Interoperability with Other Programming Models\n", "\n", "OpenMP can interoperate with other programming models, such as MPI (Message Passing Interface) or CUDA, to take advantage of specific features of different parallel programming approaches.\n", "\n", - "**Example: Interoperability with MPI**\n", + "**Example: Interoperability with MPI**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f752bb9f-ca0a-4f68-9b28-5156082e4c3d", + "metadata": {}, + "outputs": [], + "source": [ + "//%compiler: clang\n", + "//%cflags: -fopenmp\n", "\n", - "```c\n", "#include \n", "#include \n", "#include \n", @@ -753,9 +1033,14 @@ "\n", " MPI_Finalize();\n", " return 0;\n", - "}\n", - "```\n", - "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "db149383-6276-4cc7-a3b9-7d5340b1557c", + "metadata": {}, + "source": [ "In this example, OpenMP is used in conjunction with MPI, where each MPI process executes an OpenMP `teams` region on a device. This allows for a hybrid parallel programming approach that combines distributed memory parallelism (MPI) with shared memory parallelism (OpenMP).\n", "\n", "### Summary\n",